承诺所有异步操作

Question

我有两个异步操作需要不同的时间来执行，比如说

1 .一个操作需要 1 秒执行
2.其他操作 10 秒执行

我想使用promise.all，这两个操作将并行执行（我知道在js中没有多线程的概念......） 并且都在同一个踏板上执行， 当我使用 promise all 时，我 预计 op1 将在 op2 之前完成 这不会发生......知道我在这里错过了什么吗？ （可以说 op1 在我的服务器（1 秒） op2（10 秒）中保存一些小东西，当我在 1 秒后检查时，我没有看到 op1 在两个都完成后完成......）。 我知道承诺都将在两者都完成（解决）后完成。

Promise.all([op1, op2]).then(values => { 
  console.log(values);
}, reason => {
  console.log(reason)
});

Answer 1

我想用promise.all这两个操作将并行执行...

请注意，使用Promise.all 与操作是否并行执行没有任何关系。它所做的只是给你一个承诺，当两个操作都成功或当 其中一个 操作失败时被拒绝。

让我们看看你的代码，见 cmets：

Promise.all([op1, op2]).then(values => { 
  // This will happen when BOTH op1 and op2 are done
  console.log(values);
}, reason => {
  // This will happen when EITHER op1 OR op2 fails
  console.log(reason);
});

因此，如果 op1 需要 1 秒，op2 需要 10 秒并且我们假设它们都成功，则您的回调将在 10 秒后执行（当 op2 完成时）。如果您知道op1 只需要一秒钟，那么很可能op1 在您的Promise.all 回调被调用前几秒钟就完成了。

如果您想在op1 完成时收到通知，请在op1 上使用then。您可以单独执行此操作，也可以在执行此操作的同时使用Promise.all 在两者都完成时收到通知。

这个例子，使用setTimeout来模拟动作，可以帮助你理解；在下面，op1 需要 100 毫秒，op2 需要 1000 毫秒。为简单起见，它假设两个操作都成功：

var start = Date.now();
var op1 = startOp1();
var op2 = startOp2();
op1.then(function() {
  // Fires when op1 is successful; doesn't care about op2
  console.log("op1 done after " + (Date.now() - start) + "ms");
});
op2.then(function() {
  // Fires when op2 is successful; doesn't care about op1
  console.log("op2 done after " + (Date.now() - start) + "ms");
});
Promise.all([op1, op2]).then(function() {
  // Fires when BOTH ops are successful
  console.log("both done after " + (Date.now() - start) + "ms");
});

function startOp1() {
  return new Promise(function(resolve) {
    setTimeout(function() {
      resolve();
    }, 100);
  });
}
function startOp2(flag) {
  return new Promise(function(resolve) {
    setTimeout(function() {
      resolve();
    }, 1000);
  });
}

注意：你说这两个操作都是异步的，所以我在上面假设了。

Answer 2

当我使用 promise all 时，我希望 op1 会在 op2 之前完成，而这>不会发生......知道我在这里遗漏了什么吗？

数组块中的所有单个promise都异步执行，只有在所有promise都成功解决后才能到达.then()。

尝试分别在 op1 和 op2 的 timer 函数和 resolve 函数之间使用 console.log('op1 done') 和 console.log('op2 done')。在控制台上看到的输出将是：

    op1 done //after 1 sec
    op2 done //after 10 sec
    ['op1 done','op1 done'] //immediately follows the above one

这应该会让你相信异步的本质。还让我举一个更明显的例子，在下面的代码中从浏览器中保存了一个文本，其中 Promise p2 在 Promise p1 之前完成。在 5 分钟 (p1) 的时间段内；该文件（使用 p2）将在 .then() 执行之前保存在系统中

    var FileSaver = require('file-saver');

    var p1 = new Promise((resolve, reject) => {
    setTimeout(resolve, 5 * 60 * 1000, 'Executed Promise p2');                         
    // 5 min timer
    }); 

    var p2 = new Promise((resolve, reject) => {
    var blob = new Blob(["Hello, world!"],
    {type:"text/plain;charset=utf-8"});                                                            
    FileSaver.saveAs(blob
    , "hello world.txt");
    // Not tested it; from page: https://github.com/eligrey/FileSaver.js/
    console.log('done with Promise p1');
    resolve('Executed Promise p1')
    }); 

    Promise.all([p1, p2]).then(values => { 
    console.log(values); // ['Executed Promise p1','Executed Promise p2'] 
    });

Answer 3

对于 op1 在 op2 之前完成，可以使用以下选项之一 - 1. Promise Chaining 解释here 2. ES6 中提供的生成器。 3. ES7提供的Async-Await

因为 Promise.all() 确保不会一个接一个地并行执行。