Nel contesto dei motori Javascript lato server, che cos'è l'I / O non bloccante o l'I / O asincrono? Vedo che questo è menzionato come un vantaggio rispetto alle implementazioni lato server Java.

Sincrono vs asincrono

L'esecuzione sincrona di solito si riferisce all'esecuzione del codice in sequenza. L'esecuzione asincrona si riferisce all'esecuzione che non viene eseguita nella sequenza visualizzata nel codice. Nel seguente esempio, l'operazione sincrona fa scattare gli avvisi in sequenza. Nell'operazione asincrona, mentre alert(2)sembra eseguire secondo, non lo fa.

Sincrono: 1,2,3

alert(1);
alert(2);
alert(3);

Asincrono: 1,3,2

alert(1);
setTimeout(() => alert(2), 0);
alert(3);

Blocco vs Non blocco

Il blocco si riferisce alle operazioni che bloccano l'ulteriore esecuzione fino al termine dell'operazione. Il non blocco si riferisce al codice che non blocca l'esecuzione. Nell'esempio dato, localStorageè un'operazione di blocco in quanto blocca l'esecuzione da leggere. D'altra parte, fetchè un'operazione non bloccante in quanto non si ferma alert(3)dall'esecuzione.

// Blocking: 1,... 2
alert(1);
var value = localStorage.getItem('foo');
alert(2);

// Non-blocking: 1, 3,... 2
alert(1);
fetch('example.com').then(() => alert(2));
alert(3);

vantaggi

Un vantaggio delle operazioni asincrone e non bloccanti è che è possibile massimizzare l'utilizzo di una singola CPU e della memoria.

Esempio di blocco sincrono

Un esempio di operazioni di blocco sincrono è il modo in cui alcuni server Web come quelli in Java o PHP gestiscono le richieste di IO o di rete. Se il tuo codice legge da un file o dal database, il tuo codice "blocca" qualsiasi cosa dopo l'esecuzione. In quel periodo, la tua macchina si tiene in memoria e il tempo di elaborazione per un thread che non sta facendo nulla .

Per soddisfare altre richieste mentre il thread è bloccato, dipende dal software. Quello che fa la maggior parte dei software server è generare più thread per soddisfare le richieste aggiuntive. Ciò richiede più memoria consumata e più elaborazione.

Esempio asincrono, non bloccante

I server asincroni e non bloccanti, come quelli realizzati in Node, utilizzano solo un thread per soddisfare tutte le richieste. Ciò significa che un'istanza di Node ottiene il massimo da un singolo thread. I creatori lo hanno progettato con la premessa che l'I / O e le operazioni di rete sono il collo di bottiglia.

Quando le richieste arrivano al server, vengono gestite una alla volta. Tuttavia, quando ad esempio il codice servito deve interrogare il DB, invia il callback a una seconda coda e il thread principale continuerà a funzionare (non attende). Ora, quando l'operazione DB viene completata e restituita, il callback corrispondente viene estratto dalla seconda coda e messo in coda in una terza coda in cui sono in attesa di esecuzione. Quando il motore ha la possibilità di eseguire qualcos'altro (come quando lo stack di esecuzione viene svuotato), raccoglie un callback dalla terza coda e lo esegue.

var startTime = new Date().getTime();
var getEndTime = () => {
    var tempEndTime = new Date().getTime();
    var second = (tempEndTime - startTime)/1000
    return `took ${second} sec...to finish\n`
}

console.log('1: start App', getEndTime())
setTimeout(()=>{
    console.log('2: setTimeout', getEndTime())
}, 1000)
console.log('3: End App', getEndTime())

// console -> Process Order:  1 -> 3 -> 2