No contexto dos mecanismos Javascript do lado do servidor, o que é E / S sem bloqueio ou E / S assíncrona? Vejo isso ser mencionado como uma vantagem sobre as implementações do lado do servidor Java.
No contexto dos mecanismos Javascript do lado do servidor, o que é E / S sem bloqueio ou E / S assíncrona? Vejo isso ser mencionado como uma vantagem sobre as implementações do lado do servidor Java.
Respostas:
A execução síncrona geralmente se refere à execução de código em sequência. A execução assíncrona refere-se à execução que não é executada na sequência em que aparece no código. No exemplo a seguir, a operação síncrona faz com que os alertas sejam acionados em sequência. Na operação assíncrona, embora alert(2)
pareça executar o segundo, isso não ocorre.
Síncrono: 1,2,3
alert(1);
alert(2);
alert(3);
Assíncrono: 1,3,2
alert(1);
setTimeout(() => alert(2), 0);
alert(3);
Bloqueio refere-se a operações que bloqueiam a execução adicional até que a operação seja concluída. Não-bloqueio refere-se ao código que não bloqueia a execução. No exemplo dado, localStorage
é uma operação de bloqueio, pois interrompe a execução para leitura. Por outro lado, fetch
é uma operação sem bloqueio, pois não paralisa a alert(3)
execução.
// 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);
Uma vantagem de operações assíncronas sem bloqueio é que você pode maximizar o uso de uma única CPU e também de memória.
Um exemplo de operações de bloqueio síncrono é como alguns servidores da Web, como os de Java ou PHP, lidam com solicitações de IO ou de rede. Se o seu código lê de um arquivo ou do banco de dados, seu código "bloqueia" tudo após a execução. Nesse período, sua máquina está mantendo a memória e o tempo de processamento de um thread que não está fazendo nada .
Para atender a outras solicitações enquanto o encadeamento está parado, depende do seu software. O que a maioria dos softwares de servidor faz é gerar mais threads para atender a solicitações adicionais. Isso requer mais memória consumida e mais processamento.
Servidores assíncronos e sem bloqueio - como os criados no Node - usam apenas um thread para atender a todas as solicitações. Isso significa que uma instância do Node tira o máximo proveito de um único thread. Os criadores o projetaram com a premissa de que as operações de E / S e de rede são o gargalo.
Quando as solicitações chegam ao servidor, elas são atendidas uma de cada vez. No entanto, quando o código atendido precisa consultar o banco de dados, por exemplo, ele envia o retorno de chamada para uma segunda fila e o thread principal continua em execução (não espera). Agora, quando a operação do banco de dados é concluída e retorna, o retorno de chamada correspondente é retirado da segunda fila e enfileirado em uma terceira fila na qual eles estão aguardando execução. Quando o mecanismo tem a chance de executar outra coisa (como quando a pilha de execução é esvaziada), ele pega um retorno de chamada da terceira fila e o executa.
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