De acuerdo con https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/all , dos evaluaciones en el siguiente código se ejecutan de forma asincrónica.
var p2 = Promise.all([1337, "hi"]); // non-promise values will be ignored, but the evaluation will be done asynchronouslyy se me ocurre una duda que, en el siguiente ejemplo:
async function sleep(x) { await new Promise((resolve) => setTimeout(resolve, x)) } async function test(x) { await sleep(1000); return x } async function run(){ let promises = [] promises.push(test(1)) promises.push(test(2)) let res = await Promise.race(promises) console.log(res) } run() // I ran it for several times, and it always give me 1Dado que estas dos evaluaciones se ejecutaron de forma asíncrona y consumen la misma cantidad de tiempo, ¿es posible que este programa me dé 2 en algunos casos?
Lo que no entiendo es:
let a = 0 async function test1() { a++; } async function run(){ let promises = [] for (let i=0;i<100;i++){ promises.push(test1()) } await Promise.all(promises) console.log(a) } run() // It always give me 100Parece que nunca viola la atomicidad, ¿por qué?
No. Cómo funciona el bucle de eventos en javascript, colocará dos devoluciones de llamada de tiempo de espera en una "cola de tiempo de espera" y debido a que ambos tiempos de espera tienen el mismo retraso de tiempo de espera (1000), sus devoluciones de llamada se ejecutarán en el orden en que aparecen en el "tiempo de espera cola". Primero "1", luego "2".
¿Por qué este programa siempre me da 1? Si varias evaluaciones consumen la misma cantidad de tiempo, ¿javascript promete que la anterior siempre terminará antes?
La otra respuesta respondió esto: los tiempos de espera se resuelven en el orden en que se colocan en la cola. La fecha límite de tiempo de espera para la promesa 2 siempre es necesariamente posterior a la de la promesa 1 de todos modos, ya que habrá pasado algún tiempo entre promises.push(test(1)) y promises.push(test(2)) .
La segunda pregunta:
¿El cambio de contexto de hilo ocurre en Promise.all ()? Probé otro código de ejemplo de subprocesos múltiples y siempre me da 100.
No, no probó los subprocesos múltiples porque no hay subprocesos múltiples en JavaScript normal.
Una función async es síncrona hasta que la primera await en ella (y endulza su valor de retorno para envolverlo en una promesa), por lo que
async function test1() { a++; // implicit return undefined; }es equivalente a
function test1() { a++; return Promise.resolve(undefined); }Esto significa que
async function run() { let promises = [] for (let i = 0; i < 100; i++) { promises.push(test1()) } await Promise.all(promises) console.log(a) }es equivalente a
async function run() { let promises = [] for (let i = 0; i < 100; i++) { a++; promises.push(Promise.resolve(undefined)); } await Promise.all(promises); console.log(a); } que es claramente síncrono en la forma en que modifica a archivo .