Skip to content
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'.
JavaScript
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Failed to load latest commit information.
build_tests
lib
tests
.gitignore
.npmignore
.travis.yml
Gruntfile.js
license
package.json
readme.md

readme.md

Paratask - Node/io.js Parallel Process Manager

Build Status NPM version

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

Note: Scope dependency injection is at your service. More into in the examples below.

Note: This modules uses ES5 "callback" style. If you're more into the Promises/A+ standard you can use paratask-promises

Install

You can install Paratask with the Node Package Manager:

npm install paratask

or by getting it from this repo.

Dependencies

Paratask uses only native Node/io.js modules that do not need additional installation: fs and child_process.

Example: Parallel calculation

Both task_1 and task_2 will fork a new Node/io.js process and will run concurrently. When both call callback(), the final results will be printed in the console.

Note: scope property is your dependency injector. Can only be a valid JSON.parse() value (i.e. no functions allowed).

var paratask = require('paratask');

var task_1 = {
  fork: function (callback) {
    // Some calculation using the 'count' scope var
    var result = count * 10;
    callback(null, result);
  },
  scope: {
    count: 10
  }
};

var task_2 = {
  fork: function (callback) {
    // Some calculation using the 'count' scope var
    var result = count * 10;
    callback(null, result);
  },
  scope: {
    count: 20
  }
};

paratask([ task_1, task_2 ], function (error, results) {
  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
});

Example: Error handling

Both task_1 and task_2 will fork a new process but when task_2 call callback('Error message') both processes will be killed and the final callback will be executed.

Note: scope property is optional.

var paratask = require('paratask');

var task_1 = {
  fork: function (callback) {
    var count     = 1000000000;
    var factorial = 1;

    while (--count) factorial *= count;

    callback(null, factorial);
  }
};

var task_2 = {
  fork: function (callback) {
    callback('Error message');
  }
};

paratask([ task_1, task_2 ], function (error, results) {
  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
});

Comparison tests

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

Heavy calculation test:

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

Conclusion

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.

Something went wrong with that request. Please try again.