JavaScript - Thread, Asynchronous, Ticks

I think the best way to clarify this problem is to highlight the difference between competition and parallelism and the difference between cooperative competition and > preemptive .

In parallel computing you have several things running at the same time (literally, multiprocessors) but not necessarily these computations will interact with each other.

If you are doing competing computations, you have more than one "execution line" running at any given time, but they may be running on a single processor. The run line runs a little, then it pauses, and line B rolls a little, so it goes.

Finally, in a situation where you have multiple lines of execution sharing a processor, this sharing may be cooperative or preemptive.

• In a cooperative situation the execution lines explicitly give up the processor. In Javascript this occurs every time you make an asynchronous system call, which returns the pro loop control of events.
• On the other hand, in a situation with preemptive competition the system can stop execution at any time. This is what happens with the processes in your operating system or in the traditional threads you already know.

Returning to your problem, what happened is that the loop function never returns the control to the event loop. It is a simple while and this while will continue to run until the stop condition is false. In the end, you've implemented a spin lock .

One way to solve this problem is to set a timeout between each iteration of the loop.

function meuloop(){
    var current = new Date();
    if(betweenDates(current.toTimestamp(), start.toTimestamp(), 's') < 5){
        // Peça para o loop de eventos continuar o  "meu loop" assim que puder.
        // Dessa forma, o loop de eventos tem a oportunidade de
        // rodar outros eventos também.
        setTimeout(meuloop, 0);
    }else{
        console.log("acabou");
    }
}

BTW, on the node you can also use the nextTick function rather than a timeout with zero:

proccess.nextTick(meuloop)

Its betweenDates function is very imprecise, it never uses the millisecond information objects of type Date include. I did a test by changing your code a bit, and the result was 5.007 seconds:

(function(){
    var start = null;

    var checkTicks = function(){
        start = new Date();         // SETA start COM DATA CORRENTE
        setTimeout(showDiff, 1000); // DEFINE FUNÇÃO A SER EXECUTADA APOS 1s
        loop();                     // CHAMADO DE LOOP QUE DEVE DEMORAR 5s
    }

    var loop = function(){
        var stop = false;
        while(!stop){
            var current = new Date();
            if(betweenDates(current, start) > 5){ // SO PARA APOS DIFF DE 5s
                stop = true;
            }
        }
    }

    var showDiff = function(){
        var current = new Date();
        console.log(betweenDates(current, start)); // EXIBE DIFERENCA ENTRE start E current
    }

    checkTicks(); // INICIO O PROCESSO
})();

function betweenDates(d1, d2) {
    return (d1.getTime() - d2.getTime()) / 1000;
}

link

This video explains how an Event Loop works. An event loop is implemented during the video.

Thisisthecodeyouputattheendofthevideo.