I wondered how many times can a JavaScript while statement (in Chrome's console) can increment a variable in a millisecond, so I quickly wrote this snippet directly into console:
var run = true, i = 0;
setTimeout(function(){ run = false; }, 1);
while(run){ i++; }
The problem is that it runs forever.
Why is this happening, and how can I solve it?
This comes back to the one-threaded nature of JavaScript1. What happens is pretty much this:
run = false. This is scheduled to be run after the current function is run (or whatever else is currently active).setTimeout() callback will be executed and run=false.As you can see, a setTimeout() approach wont work here. You might work around that by checking the time in the while condition, but this will tamper with your actual measurement.
1 At least for more practical purposes you can see it as single-threaded. Actually there is an so called "event-loop". In that loop all functions get queued until they are executed. If you queue up a new function, it is put at the respective position inside that queue. After the current function has finished, the engine takes the next function from the queue (with respect to timings as introduced, e.g., by setTimeout() and executes it.
As a result at every point in time just one function is executed, thus making the execution pretty much single threaded. There are some exceptions for events, which are discussed in the link below.
For reference:
https://mcmap.net/q/161790/-javascript-event-handling-while-inside-of-loop
Here a similar scenario was explained in more detail
https://mcmap.net/q/63567/-is-javascript-guaranteed-to-be-single-threaded
A more in-depth description on when JS can be seen as single-threaded and when not.
var start = (new Date()).getTime(); Then in the while statement subtract that time from the current time and check to see if the resulting number is less than your intended delay. while ((new Date()).getTime() - start < delay). –
Amalita JavaScript is single-threaded so, while you are in the loop, nothing else gets executed.
To keep the true speed of Chrome without having to constantly retrieve the time to calculate speed, you could try this JS code:
var start = new Date().getTime()
var i = 0
while(i<1000000)
{
i++
}
var end = new Date().getTime()
var delta = end-start
var speed = i/delta
console.log(speed + " loops per millisecond")
Javascript is single-threaded, that mean it runs only one instruction at a time, sequentially.
The event system, like in many other languages and library, is handle by an event loop. The event loop is basically a loop, which on each iteration check for message in the queue, and dispatch events.
In javascript (as in mot of languages implementing this pattern), the event loop is called when the stack is empty, that is to say, when all functions have returns, in other word, at the end of the program code.
Your "real" program look something like this behind the scene :
var run = true, i = 0;
setTimeout(function(){ run = false; }, 1);
while(run){ i++; }
while(true) {
/*
* check for new messages in the queue and dispatch
* events if there are some
*/
processEvents();
}
So the message from the clock saying timeout is over is never processed.
More info on the event loop on : https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/EventLoop
Of course it is a bit more complex, check here those examples : Is JavaScript guaranteed to be single-threaded? (tl;dr: In some browser engines, some external events are not dependent on the event loop and are immediately fired when they occur, preempting the current task. But this is not the case with setTimeout, which just add a message to the queue and never fires immediately.)
The While loop doesn't access the setTimeout. You have code that sets run true, and then it will never become false.
JavaScript has single thread and has single-threaded anywhere.
I think this question in good: Is JavaScript guaranteed to be single-threaded?
When your code is in loop other ocde not execute and block.
© 2022 - 2024 — McMap. All rights reserved.
var run = true, i = 0; function loop() { i++; if (run) setTimeout(loop, 0); }; setTimeout(function() { run = false }, 1); loop();– Herren4msper definition. So you waste a lot of time in the timeout and function calls. – Binion