# forkify

> Run synchronous functions inside a forked child process

Latest version **0.1.3** (published 2015-06-04) · MIT license · 0 weekly downloads

## Install

```sh
npm install forkify
pnpm add forkify
yarn add forkify
bun add forkify
```

## Health

**Score 15/100 (F)** — status: abandoned.

Positive: no vulnerabilities.

Warnings: low downloads; no types; no esm support; pre 1.0.

Negative: abandoned; low maintenance score.

## Facts

| | |
|---|---|
| Version | 0.1.3 |
| Published | 2015-06-04 |
| First published | 2015-05-28 |
| Weekly downloads | 0 |
| License | MIT |
| TypeScript types | none |
| Module format | CommonJS |
| Node | >=0.10 |
| Dependencies | 1 |
| Known vulnerabilities | 0 |
| Install scripts | no |
| GitHub stars | 2 |
| Author | Jelle De Loecker |
| Maintainers | skerit |
| Keywords | flow-control, asynchronous, asyncify, async, callback, fork, child_process |

## Links

- npm: https://www.npmjs.com/package/forkify
- Repository: https://github.com/skerit/forkify
- Homepage: https://github.com/skerit/forkify#readme
- Issues: https://github.com/skerit/forkify/issues
- npm.io page: https://npm.io/package/forkify

## Dependencies (1)

- [toobusy-js](https://npm.io/package/toobusy-js.md) ~0.4.2

## Alternatives

- [promise-throttle](https://npm.io/package/promise-throttle.md) — 44.2K weekly downloads
- [@commercetools/sync-actions](https://npm.io/package/@commercetools/sync-actions.md) — 25.1K weekly downloads
- [cwait](https://npm.io/package/cwait.md) — 21.4K weekly downloads
- [@ledgerhq/hw-app-cosmos](https://npm.io/package/@ledgerhq/hw-app-cosmos.md) — 4.2K weekly downloads
- [@financial-times/o-loading](https://npm.io/package/@financial-times/o-loading.md) — 2.8K weekly downloads

## Recent versions

- 0.1.3 (latest) — 2015-06-04
- 0.1.1 — 2015-05-29
- 0.1.0 — 2015-05-28

## README

# Forkify

Forkify lets you run functions in a forked child process

## Install

```bash
$ npm install forkify
```

## Features

* Distribute executions over multiple instances
* Create new instances when existing ones are too busy
* Buffers & streams are sent over a separate socket
  to bypass costly JSON serialization
* Idle instances are reaped (by default after 30 seconds)
* Events can be emitted from the fork

## Todo

* You should also be able to send events to the fork
* Emitted event arguments should be serialized through the same process as
  a function execution or callback, so buffers & streams can also be emitted

## Examples

### Forkify a function

```javascript
var forkify = require('forkify');

// Forkify the function
var fibonacci = forkify(function generateFibonacci(amount, callback) {
    var fib = [],
        res,
        i;

    fib[0] = 0;
    fib[1] = 1;

    for (i = 2; i <= amount; i++) {
        res = fib[0] + fib[1];

        fib[0] = fib[1];
        fib[1] = res;
    }

    // Callback with the response
    callback(null, res);
});

fibonacci(10, function gotResult(err, result) {
    console.log('Fibonacci result:', err, result);
});
```

### Work with buffers

You can pass Buffer instances back and forth, without problems.
These are not serialized using JSON, as that is a costly affair.
Unfortunately, they are also not using "shared memory", rather the buffer contents are sent to the child over an extra stream.

```javascript

var workWithBuffers = forkify(function(buffer, callback) {

    // Outputs 6 in this case
    console.log(buffer.length);

    callback(null, new Buffer(40));
});

workWithBuffers(new Buffer(6), function(err, buffer) {
    // Outputs 40 in this case
    console.log(buffer.length);
});
```

### Set instance pool size

By default, up to 3 instances are created. This can be modified at any time like this:

```javascript
forkify.limit = 5;
```

### Create a new forkify pool

If you want to create a separate pool, you can do so like this:

```javascript
var forkify2 = forkify.constructor();
```

### Set minimum idle time before reaping

Forks are killed after idling for at least 30 seconds.
This can be changed by setting the `idle` property:

```javascript
forkify.idle = 45000; // 45 seconds
```

Do note: For now, the reaping function only runs once every 10 seconds.

## Caveats

`forkify` functions run in a new scope and can not access anything outside of it, you will have to re-`require` modules you wish to use inside the function.

Arguments passed to the forkified function are converted using a modified version of JSON-DRY (which supports Dates, Infinity, Errors, Buffers, ...)

Because of the addition of Buffer support `forkify` will keep your application running until all instances have been reaped.

## License

MIT

---
_Source: https://npm.io/package/forkify · Machine-readable twin of the npm.io package page. Health data is recomputed on every publish._