Ідіоматичний спосіб чекати декількох зворотних викликів у Node.js


99

Припустимо, вам потрібно виконати деякі операції, які залежать від певного файлу temp. Оскільки ми тут говоримо про Node, ці операції, очевидно, асинхронні. Який ідіоматичний спосіб дочекатися завершення всіх операцій, щоб знати, коли можна видалити тимчасовий файл?

Ось код, який показує, що я хочу зробити:

do_something(tmp_file_name, function(err) {});
do_something_other(tmp_file_name, function(err) {});
fs.unlink(tmp_file_name);

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

Я думав про використання емітерів подій у зворотному звороті та реєстрацію лічильника як приймача. Лічильник отримав би готові події і підрахував, скільки операцій ще очікує. Коли останній закінчився, він видалить файл. Але є ризик стану гонки, і я не впевнений, що зазвичай це робиться.

Як люди Вузла вирішують подібну проблему?


Дякую за це запитання, у мене теж є подібне питання.
— Кришна Шетті

Відповіді:


94

Оновлення:

Тепер я радив би поглянути на:

  • Обіцянки

    Об'єкт Promise використовується для відкладених та асинхронних обчислень. Обіцянка - це операція, яка ще не завершена, але очікується в майбутньому.

    Популярна бібліотека обіцянок - синій птах . А порадив би поглянути на те, чому обіцяє .

    Для цього вам слід використовувати обіцянки:

    fs.readFile("file.json", function (err, val) {
        if (err) {
            console.error("unable to read file");
        }
        else {
            try {
                val = JSON.parse(val);
                console.log(val.success);
            }
            catch (e) {
                console.error("invalid json in file");
            }
        }
    });
    

    У це:

    fs.readFileAsync("file.json").then(JSON.parse).then(function (val) {
        console.log(val.success);
    })
    .catch(SyntaxError, function (e) {
        console.error("invalid json in file");
    })
    .catch(function (e) {
        console.error("unable to read file");
    });
    
  • генератори: Наприклад, через co .

    Користь потоку управління на основі генераторів для nodejs та браузера, використовуючи обіцянки, дозволяючи вам писати незаблокуючий код на приємний результат.

    var co = require('co');
    
    co(function *(){
      // yield any promise
      var result = yield Promise.resolve(true);
    }).catch(onerror);
    
    co(function *(){
      // resolve multiple promises in parallel
      var a = Promise.resolve(1);
      var b = Promise.resolve(2);
      var c = Promise.resolve(3);
      var res = yield [a, b, c];
      console.log(res);
      // => [1, 2, 3]
    }).catch(onerror);
    
    // errors can be try/catched
    co(function *(){
      try {
        yield Promise.reject(new Error('boom'));
      } catch (err) {
        console.error(err.message); // "boom"
     }
    }).catch(onerror);
    
    function onerror(err) {
      // log any uncaught errors
      // co will not throw any errors you do not handle!!!
      // HANDLE ALL YOUR ERRORS!!!
      console.error(err.stack);
    }
    

Якщо я правильно розумію, я думаю, ви повинні подивитися на дуже гарну бібліотеку асинхронізації . Особливо слід ознайомитись із серією . Просто копія фрагментів зі сторінки github:

async.series([
    function(callback){
        // do some stuff ...
        callback(null, 'one');
    },
    function(callback){
        // do some more stuff ...
        callback(null, 'two');
    },
],
// optional callback
function(err, results){
    // results is now equal to ['one', 'two']
});


// an example using an object instead of an array
async.series({
    one: function(callback){
        setTimeout(function(){
            callback(null, 1);
        }, 200);
    },
    two: function(callback){
        setTimeout(function(){
            callback(null, 2);
        }, 100);
    },
},
function(err, results) {
    // results is now equals to: {one: 1, two: 2}
});

Як плюс, ця бібліотека також може працювати в браузері.


21
Я фактично використовував async.parallel, оскільки операції є незалежними, і я не хотів змушувати їх чекати попередніх.
— Тіаго Аррайз

22

Найпростіший спосіб збільшити цілочисельний лічильник під час запуску операції асинхронізації, а потім у зворотному дзвінку зменшити лічильник. Залежно від складності, зворотний дзвінок може перевірити лічильник на нуль, а потім видалити файл.

Трохи складніше було б підтримувати список об’єктів, і кожен об’єкт мав би будь-які атрибути, які вам потрібні для ідентифікації операції (це навіть міг бути виклик функції), а також код статусу. Зворотні виклики встановили б код статусу завершеним.

Тоді у вас з’явиться цикл, який чекає (використовуючи process.nextTick) і перевіряє, чи всі завдання виконані. Перевага цього методу над лічильником полягає в тому, що якщо є можливість завершити всі невирішені завдання, перш ніж видавати всі завдання, техніка лічильника призведе до того, що ви видалите файл передчасно.


11
// simple countdown latch
function CDL(countdown, completion) {
    this.signal = function() { 
        if(--countdown < 1) completion(); 
    };
}

// usage
var latch = new CDL(10, function() {
    console.log("latch.signal() was called 10 times.");
});

7

Немає «нативного» рішення, але є мільйон бібліотек управління потоком для вузла. Можливо, вам сподобається крок:

Step(
  function(){
      do_something(tmp_file_name, this.parallel());
      do_something_else(tmp_file_name, this.parallel());
  },
  function(err) {
    if (err) throw err;
    fs.unlink(tmp_file_name);
  }
)

Або, як запропонував Майкл, лічильники можуть бути більш простим рішенням. Погляньте на цей макет семафору . Ви використовуєте це так:

do_something1(file, queue('myqueue'));
do_something2(file, queue('myqueue'));

queue.done('myqueue', function(){
  fs.unlink(file);
});

6

Я хотів би запропонувати ще одне рішення, яке використовує швидкість та ефективність парадигми програмування в самому ядрі Node: подій.

Все, що ви можете зробити з Обіцянками або модулями, призначеними для управління потоковим контролем, як-от async, можна досягти, використовуючи події та просту стан-машину, яка, на мою думку, пропонує методологію, яку, мабуть, легше зрозуміти, ніж інші варіанти.

Наприклад, припустимо, що ви хочете паралельно підсумовувати довжину декількох файлів:

const EventEmitter = require('events').EventEmitter;

// simple event-driven state machine
const sm = new EventEmitter();

// running state
let context={
  tasks:    0,    // number of total tasks
  active:   0,    // number of active tasks
  results:  []    // task results
};

const next = (result) => { // must be called when each task chain completes

  if(result) { // preserve result of task chain
    context.results.push(result);
  }

  // decrement the number of running tasks
  context.active -= 1; 

  // when all tasks complete, trigger done state
  if(!context.active) { 
    sm.emit('done');
  }
};

// operational states
// start state - initializes context
sm.on('start', (paths) => {
  const len=paths.length;

  console.log(`start: beginning processing of ${len} paths`);

  context.tasks = len;              // total number of tasks
  context.active = len;             // number of active tasks

  sm.emit('forEachPath', paths);    // go to next state
});

// start processing of each path
sm.on('forEachPath', (paths)=>{

  console.log(`forEachPath: starting ${paths.length} process chains`);

  paths.forEach((path) => sm.emit('readPath', path));
});

// read contents from path
sm.on('readPath', (path) => {

  console.log(`  readPath: ${path}`);

  fs.readFile(path,(err,buf) => {
    if(err) {
      sm.emit('error',err);
      return;
    }
    sm.emit('processContent', buf.toString(), path);
  });

});

// compute length of path contents
sm.on('processContent', (str, path) => {

  console.log(`  processContent: ${path}`);

  next(str.length);
});

// when processing is complete
sm.on('done', () => { 
  const total = context.results.reduce((sum,n) => sum + n);
  console.log(`The total of ${context.tasks} files is ${total}`);
});

// error state
sm.on('error', (err) => { throw err; });

// ======================================================
// start processing - ok, let's go
// ======================================================
sm.emit('start', ['file1','file2','file3','file4']);

Що виведе:

початок: початок обробки 4 контурів
forEachPath: запуск 4 технологічних ланцюгів
  readPath: file1
  readPath: file2
  processContent: file1
  readPath: файл3
  processContent: file2
  processContent: file3
  readPath: file4
  contentContent: file4
Всього 4 файли - 4021

Зауважте, що впорядкування завдань ланцюга технологічного процесу залежить від завантаження системи.

Ви можете передбачити потік програми як:

start -> forEachPath - + -> readPath 1 -> processContent 1 - + -> виконано
                      + -> readFile 2 -> processContent 2 - +
                      + -> readFile 3 -> processContent 3 - +
                      + -> readFile 4 -> processContent 4 - +

Для повторного використання було б тривіально створити модуль для підтримки різних моделей управління потоком, тобто серій, паралельних, пакетних, в той час, поки, і т.д.


2

Найпростіше рішення - запустити do_something * і від’єднати послідовно наступним чином:

do_something(tmp_file_name, function(err) {
    do_something_other(tmp_file_name, function(err) {
        fs.unlink(tmp_file_name);
    });
});

Якщо, з міркувань продуктивності, ви не хочете паралельно виконувати do_something () і do_something_other (), я пропоную зробити це просто і піти цим шляхом.



1

З чистими обіцянками це може бути дещо безладніше, але якщо ви використовуєте відкладені обіцянки, це не так вже й погано:

Встановити:

npm install --save @bitbar/deferred-promise

Змініть код:

const DeferredPromise = require('@bitbar/deferred-promise');

const promises = [
  new DeferredPromise(),
  new DeferredPromise()
];

do_something(tmp_file_name, (err) => {
  if (err) {
    promises[0].reject(err);
  } else {
    promises[0].resolve();
  }
});

do_something_other(tmp_file_name, (err) => {
  if (err) {
    promises[1].reject(err);
  } else {
    promises[1].resolve();
  }
});

Promise.all(promises).then( () => {
  fs.unlink(tmp_file_name);
});

Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.