worker threads vs fork process

benchmark.js

const Benchmark = require('benchmark')
const doThreadsJob = require('./microjob')
const doProcessJob = require('./workform')

var suite = new Benchmark.Suite;

suite
.add('worker threads', {
  defer: true,
  fn: function (deferred) {
    console.log('doing threads job...')
    doThreadsJob().then(() => {
      deferred.resolve()
    }).catch(err => {
      throw err
    })
  }
})
.add('fork process', {
  defer: true,
  fn: function (deferred) {
    console.log('doing process job...')
    doProcessJob().then(() => {
      deferred.resolve()
    }).catch(err => {
      throw err
    })
  }
})
// add listeners
.on('cycle', function(event) {
  console.log(String(event.target));
})
.on('complete', function() {
  console.log('Fastest is ' + this.filter('fastest').map('name'));
})
.on('error', function(err) {
  console.log('error occured!', err)
})
// run async
.run({ 'async': true });

demo-job.js

module.exports = {
  heavyJob: data => {
    let i = 0;
    let res = typeof data === "number" ? data : data.n
    for (i = 0; i < 100000000; i++) {
      res += 1
    }
  
    return res
  }
}

microjob.js

const { start, job } = require("microjob");
const { heavyJob } = require('./demo-job');

let jobStarted = false

async function ready() {
  if (jobStarted) {
    return
  }

  await start({ maxWorkers: 2 })
}

async function executeJob(n) {
  await job(heavyJob, { data: { n } })
}

async function main() {
  await ready()
  await executeJob(0)
}

// main().catch(console.error)

module.exports = main

workers.js

const { heavyJob } = require('./demo-job');

exports.heavyJob = wrap(heavyJob)

function wrap (fn) {
  return function (arg, callback) {
    try {
      const ret = fn(arg)
      callback(null, ret)
    } catch (e) {
      callback(e)
    }
  }
}

workform.js

const workerFarm = require('worker-farm');
const workers = workerFarm(
  {
    maxConcurrentWorkers: 2,
    maxConcurrentCallsPerWorker: 1,
  },
  require.resolve('./workers.js'),
  [
    'heavyJob',
  ]
);

async function main() {
  return new Promise((resolve, reject) => {
    workers.heavyJob(0, (err, out) => {
      if (err) {
        return reject(err);
      }

      resolve(out);
    });
  });
}

// main().then(console.log).catch(console.error)
module.exports = main

Instead of this:

  return new Promise((resolve, reject) => {
    workers.heavyJob(0, (err, out) => {
      if (err) {
        return reject(err);
      }

      resolve(out);
    });
  });

you can use:

  return new Promise((resolve, reject) => {
    workers.heavyJob(0, (err, out) => {
      err ? reject(err) :  resolve(out);
    });
  });