Разница между async.series и async.parallel

В чем разница между async.series и async.parallel. Рассмотрим следующий пример, и я получил тот же результат.

async.parallel([
    function(callback){
        setTimeout(function(){
            callback(null, 'one');
        }, 200);
    },
    function(callback){
        setTimeout(function(){
            callback(null, 'two');
        }, 100);
    },
    function(callback){
        setTimeout(function(){
            var err = new Error('I am the error');
            callback(err);
        }, 400);
    },
    function(callback){
        setTimeout(function(){
            callback(null, 'three');
        }, 600);
    },
],
// optional callback
function(err, results){
    if(err){
        console.log('Error');
    } else {

    }
    console.log(results);
    //results is now equal to [ 'one', 'two', undefined ]
    // the second function had a shorter timeout.
});

и

async.series([
   function(callback){
        setTimeout(function(){
            callback(null, 'one');
        }, 200);
    },
    function(callback){
        setTimeout(function(){
            callback(null, 'two');
        }, 100);
    },
    function(callback){
        setTimeout(function(){
            var err = new Error('I am the error');
            callback(err);
        }, 400);
    },
    function(callback){
        setTimeout(function(){
            callback(null, 'three');
        }, 600);
    }
],
// optional callback
function(err, results){
    //results is now equal to [ 'one', 'two', undefined ]
    if(err){
        console.log('Error');
    } else {

    }
    console.log(results);
});

Я не вижу разницы. Может, мой образец плохой? Я прочитал документацию об этих двух функциях в репозитории github async, вы можете найти для async.parallel функции:

Если какая-либо из функций передает ошибку на обратный вызов, основной обратный вызов немедленно вызывается со значением ошибки

Каков основной ответ в async.parallel?

Ответы

Ответ 1

async.series последовательно запускает ваши функции (ожидая завершения каждого предыдущего до начала следующего). async.parallel будет запускать их все одновременно (или все, что проходит одновременно для однопоточной земли).

Основной обратный вызов - это тот, который необязательно предоставляется при вызове async.parallel или async.series (подпись async.parallel(tasks, [callback]))

Итак, что происходит на самом деле:

параллель:

  • parallel запускает все задачи, а затем ждет
  • все четыре задачи планируют время ожидания
  • таймаут 100 огней, добавляет его результат (результат теперь [ , "Two"])
  • timeout 200 срабатывает, добавляет его результат (результат теперь ["One", "Two"])
  • timeout 400 срабатывает, возвращает ошибку и undefined в результате (результат теперь ["One", "Two", undefined])
  • parallel замечает ошибку, сразу возвращает результат, полученный до сих пор
  • таймаут 600 огней, но никто не заботится о результатах возврата

Серия:

  • series запускает первую задачу; он назначает свой тайм-аут.
  • series ждет, пока обратный вызов будет вызван через 200 мс, а затем добавит результат. (результат теперь ["One"])
  • series запускает вторую задачу; он назначает свой тайм-аут.
  • series ожидает, что обратный вызов будет вызван через 100 мс, а затем добавит результат. (результат теперь ["One", "Two"])
  • series запускает третью задачу; он назначает свой тайм-аут.
  • series ожидает, что обратный вызов будет вызван через 400 мс, затем добавит результат и выйдет из-за ошибки. (результат теперь ["One", "Two", undefined])
  • четвертая задача никогда не выполняется, и ее таймаут никогда не планируется.

Тот факт, что вы получили тот же результат, связан с тем, что вы полагаетесь на setTimeout в своих задачах.

Как использовать parallel полезно, попробуйте загрузить сотню веб-страниц с помощью parallel; затем сделайте то же самое с series. Посмотрите, что произойдет.

Ответ 2

Как вы можете видеть в документации:

  • Для async.series:

Запустите массив последовательностей, каждый из которых запускается после завершения предыдущей функции.

это означает, что async будет ожидать, что функция "n" закончится до вызова "n + 1".

  • Для async.parallel

Запуск массива функций параллельно, не дожидаясь завершения предыдущей функции.

Но ваш фрагмент кода слишком прост, чтобы увидеть разницу. Если оба они работают на вас, вы должны выбрать async.parallel, это быстрее.