Comments on: Ajax, javascript and threads : the final truth

By: ireshagun

ireshagun — Fri, 18 Dec 2009 01:25:34 +0000

There is a legitimate way of multi-threading in java without all these artificial constructs.

http://codediaries.blogspot.com/2009/12/real-javascript-multithreading-using.html

By: joseanpg

joseanpg — Tue, 31 Jul 2007 00:59:27 +0000

He probado el cÃ³digo de ix en FF e IE y el comportamiento es el esperado: la ejecuciÃ³n de la funciÃ³n pasada en el setTimeout sÃ³lo ocurre cuando el bloque de cÃ³digo que la “lanza” ha terminado. Es decir, los alert no permiten que los asincronos “expropien” al bloque de cÃ³digo que ejecuto el alert.

var nullable = null;
var loop = 500000;
var timeOut = setTimeout(function(){alert(nullable)}, 1);
for(var i = 0;i

By: Julien Couvreur

Julien Couvreur — Thu, 14 Jun 2007 22:23:06 +0000

You can implement a form of multi-threading in javascript, by having your code voluntarily yield execution and a scheduler object to give each thread some time.
Neil Mix wrote a library to allow this in javascript. I blogged about it at: http://blog.monstuff.com/archives/000315.html

By: Andrea Giammarchi

Andrea Giammarchi — Thu, 14 Jun 2007 21:20:50 +0000

Kris, it’s not a “so perfect” answer because if You generate a modal event inside long execution code (i.e. alert(”go on, async queue”);) ajax, as intervals, starts while function execution is “blocked” :-)

for(var nullable = null, i = 0, loop = 500000, timeOut = setTimeout(function(){alert(nullable)}, 1); i < loop; i++ ) { if(i + 1 === loop) { // comment this alert to read Hello World alert("nullable not yet setted");

nullable = "Hello World"; } };

By: ix

ix — Thu, 14 Jun 2007 19:03:39 +0000

tim: JS isnt tail recursive? also have you considered using DOM synthetic events as a message passing idiom instead building up some tower of babel in callbacks..

By: Kris Zyp

Kris Zyp — Thu, 14 Jun 2007 17:58:46 +0000

The browser JS engine has a queue that it uses to process events (ajax responses, and setTimeouts count as events here). The queue just processes one event after another, one at a time. Each time an event is finished (which may take a lot of time as you observed), it will execute the next one. That is why you observe this behavior.

By: Andrea Giammarchi

Andrea Giammarchi — Thu, 14 Jun 2007 15:12:53 +0000

… oops …

for(var
nullable = null,
i = 0,
loop = 500000,
timeOut = setTimeout(function(){alert(nullable)}, 1);
i < loop; i++
) {
if(i + 1 === loop)
nullable = “Hello World”;
};

By: Andrea Giammarchi

Andrea Giammarchi — Thu, 14 Jun 2007 15:12:17 +0000

c’mon guys …

for(var
nullable = null,
i = 0,
loop = 500000,
timeOut = setTimeout(function(){alert(nullable)}, 1);
i

By: Carlos Aguayo

Carlos Aguayo — Thu, 14 Jun 2007 14:38:28 +0000

Brendan Eich wrote an article about threads a couple of months ago…
http://weblogs.mozillazine.org/roadmap/archives/2007/02/threads_suck.html

By: Al Jourgenson

Al Jourgenson — Thu, 14 Jun 2007 13:09:01 +0000

Just a minor typo…

“a long running function that fires of an XHR request”

should be:

“a long running function that fires off an XHR request”

By: Tim Cooijmans

Tim Cooijmans — Thu, 14 Jun 2007 11:47:00 +0000

Is this really news to anyone? If you hog the CPU, it’ll block asynchronous stuff, such as XMLHttpRequests and setTimeouts. This is also quite consistent across browsers and platforms. (The alert() just temporarily stops your scripts from hogging the CPU until you dismiss the dialog.)

As for the breaking up of functions, I’m personally getting into the habit of using callbacks for everything:

function foo () {
// does stuff…

// calls another function
sleep(10, function () {
// rest of a goes on here after 10 seconds
});
}

function sleep (secs, callback) {
// sleep returns by calling a’s callback
setTimeout(callback, secs * 1000);
}

This way, it doesn’t matter if a function does synchronous or asynchronous stuff. You give every function a callback and it will return using that callback. The callback is kind of a continuation.

One problem is that this quickly builds up a huge call stack. You can get rid of the call stack by calling a callback with setTimeout.