paratask

Paratask is a tool that will execute your JavaScript code in parallel using the full potential of multi-process programming. In contrast to asynchronous task management, Paratask will create a child Node.js process in which your task will 'live'.

Paratask - Node.js Parallel Tasks Manager

Paratask is a tool that will execute your Node.js code in parallel using the full potential of multi-process programming. In contrast to asynchronous task management, Paratask will create a child Node.js process in which your task function will 'live'.

Warning: This means that your task function will be able to get only a non-functional context dependencies. More into in the examples below.

You can install Paratask with the Node Package Manager:

npm install paratask

or by getting it from this repo.

Paratask uses only general Node.js modules that do not need additional installation: fs, child_process, and domain.

Both task_1 and task_2 will fork a Node.js process, execute their functions and when both call callback(), the final error state and results will be printed in the console.

Warning: context property can only be a valid JSON.parse() value (i.e. no functions allowed).

var paratask = require('paratask');
 
var task_1 = {
  forkfunction (callback) {
    // Some calculation using the 'count' context var 
    var result = count * 10;
    callback(null, result);
  },
  context: {
    count: 10
  }
};
 
var task_2 = {
  forkfunction (callback) {
    // Some calculation using the 'count' context var 
    var result = count * 10;
    callback(null, result);
  },
  context: {
    count: 20
  }
};
 
paratask([ task_1, task_2 ], function (errorresults) {
  console.log( error   );  // null 
  console.log( results );  // [100, 200], 1st task result will be always the 1st in the results array even if completed last 
});

Both task_1 and task_2 will fork a Node.js process but from the moment when task_2 call callback('Error message') both processes will be killed and the final callback will be executed, printing the 1st occurred error and the results array in the moment of error occurrence.

Note: context property is optional.

var paratask = require('paratask');
 
var task_1 = {
  forkfunction (callback) {
    var
    count     = 100000,
    factorial = 1;
 
    while (--count) factorial *= count;
 
    callback(null, factorial);
  }
};
 
var task_2 = {
  forkfunction (callback) {
    callback('Error message');
  }
};
 
paratask([ task_1, task_2 ], function (errorresults) {
  console.log( error   );  // 'Error message' 
  console.log( results );  // [], the results array may not have any data saved since one task error will kill all forked tasks 
});

A palette of comparison tests between paratask(), async.parallel(), and process.nextTick() are available in ./tests folder.

node tests/async_heavy_test.js
node tests/process_nextTick_heavy_test.js
node tests/paratask_heavy_test.js

Paratask is great when you have several time consuming task functions with few external dependencies. In such cases, multi-processing is the best approach. When you want to manage several relevantly quick functions with asynchronous logic, async will handle it with beauty.