node.js - with - node js writehead

¿Qué es exactamente un tic del evento Node.js?

Question

He estado adentrándome más en la parte interna de la arquitectura node.js, y un término que veo que viene mucho es "tic" como en "siguiente tic del bucle de evento" o la función nextTick() .

Lo que no he visto es una definición sólida de lo que es exactamente un "tic". Basado en varios artículos ( como este ), he sido capaz de armar un concepto en mi cabeza, pero no estoy seguro de qué tan preciso sea.

¿Puedo obtener una descripción precisa y detallada de un evento node.js loop tick?

Answer 1

Recuerde que si bien JavaScript tiene un solo subproceso, todas las E / S y las llamadas a las API nativas del nodo son asincrónicas (utilizando mecanismos específicos de la plataforma) o se ejecutan en un subproceso separado. (Todo esto se maneja a través de libuv).

Entonces, cuando hay datos disponibles en un socket o una función de API nativa ha regresado, necesitamos una forma sincronizada para invocar la función de JavaScript que está interesada en el evento particular que acaba de suceder.

No es seguro llamar simplemente a la función JS desde el hilo donde ocurrió el evento nativo por las mismas razones que encontrarías en una aplicación común de múltiples subprocesos: condiciones de carrera, acceso a memoria no atómica, etc.

Entonces, lo que hacemos es colocar el evento en una cola de manera segura. En psuedocode simplificado, algo así como:

lock (queue) {
    queue.push(event);
}

Luego, de vuelta en el hilo principal de JavaScript (pero en el lado C de las cosas), hacemos algo como:

while (true) {
    // this is the beginning of a tick

    lock (queue) {
        var tickEvents = copy(queue); // copy the current queue items into thread-local memory
        queue.empty(); // ..and empty out the shared queue
    }

    for (var i = 0; i < tickEvents.length; i++) {
        InvokeJSFunction(tickEvents[i]);
    }

    // this the end of the tick
}

El while (true) (que no existe realmente en el código fuente del nodo, esto es puramente ilustrativo) representa el bucle de evento . El interior for invoca la función JS para cada evento que estaba en la cola.

Este es un tic: la invocación síncrona de cero o más funciones de devolución de llamada asociadas con cualquier evento externo. Una vez que la cola se vacía y la última función regresa, el tic ha terminado. Volvemos al principio (el siguiente tic) y buscamos eventos que se agregaron a la cola de otros hilos mientras nuestro JavaScript se estaba ejecutando .

¿Qué puede agregar cosas a la cola?

• process.nextTick
• setTimeout / setInterval
• E / S (cosas de fs , net , etc.)
• las funciones intensivas del procesador de crypto como las secuencias de cifrado, pbkdf2 y el PRNG (que en realidad son un ejemplo de ...)
• cualquier módulo nativo que use la cola de trabajo libuv para hacer que las llamadas a bibliotecas C / C ++ sincrónicas se vean asíncronas

Answer 2

Una respuesta más simple para los nuevos en JavaScript:

Lo primero que debe entender es que JavaScript es un "entorno de subproceso único". Esto se refiere al comportamiento de JavaScript de ejecutar los bloques de código uno a la vez desde "el bucle de evento" en un solo hilo. A continuación hay una implementación rudimentaria del ciclo de eventos tomado del libro ydkJS de Kyle Simpson y luego, una explicación:

// `eventLoop` is an array that acts as a queue (first-in, first-out)
var eventLoop = [ ];
var event;

// keep going "forever"
while (true) {
    // perform a "tick"
    if (eventLoop.length > 0) {
        // get the next event in the queue
        event = eventLoop.shift();

        // now, execute the next event
        try {
            event();
        }
        catch (err) {
            reportError(err);
        }
    }
}

El primer ciclo while simula el ciclo de eventos. Un tic es la eliminación de un evento de la "cola de bucle de evento" y la ejecución de dicho evento.

Consulte la respuesta de ''Josh3796'' para obtener una explicación más detallada de lo que sucede en la eliminación y ejecución de un evento.

También recomiendo leer el libro de Kyle Simpson para aquellos que estén interesados ​​en obtener una comprensión profunda de JavaScript. Es completamente gratuito y de código abierto y se puede encontrar en este enlace: https://github.com/getify/You-Dont-Know-JS

La sección específica a la que hice referencia se puede encontrar aquí: https://github.com/getify/You-Dont-Know-JS/blob/master/async%20%26%20performance/ch1.md#event-loop