Worker Threads

Offload CPU-intensive tasks to worker threads in Node.js to keep your Express server responsive. Includes a reusable worker service and a Fibonacci demo route.

worker-threadsmultithreadingperformanceexpressjavascriptnode

v2.0.0utility

Overview

A production-grade demonstration of Node.js Worker Threads for executing CPU-heavy computations without blocking the main event loop. Ideal for handling complex calculations, image processing, or encryption in scalable Express applications.

Installation

CLI

npx backternity add worker-threads-example

What This Does

Installs a worker-thread utility with Express integration to run CPU-bound tasks (like Fibonacci calculations) off the main thread.

Files & Folders Created

File / Path	Description
/src/worker.js	Defines the CPU-heavy task (Fibonacci example).
/src/services/workerService.js	Manages worker thread creation and lifecycle.
/src/routes/heavyTask.js	Express route to trigger worker computation.
/server.js.example	Example Express server with worker endpoint.

Files to be modified

File / Path	Description
server.js	Adds a new route /api/calculate-fibonacci using worker threads.

Configuration

# Environment Variables
PORT=3001
NODE_ENV=development

Frontend Integration

You can trigger heavy computations like Fibonacci calculations directly from your frontend (Next.js or React). The computation runs on a worker thread, ensuring the main API remains responsive.

GET/api/calculate-fibonacci?number=40

Executes a CPU-intensive Fibonacci calculation in a worker thread and returns the result asynchronously.

Example

// app/workers/FibonacciClient.jsx (Next.js example)
'use client';
import { useState } from 'react';

export default function FibonacciClient() {
  const [number, setNumber] = useState(40);
  const [result, setResult] = useState(null);
  const [loading, setLoading] = useState(false);

  async function calculateFibonacci() {
    setLoading(true);
    setResult(null);
    try {
      const res = await fetch(`/api/calculate-fibonacci?number=${number}`);
      const data = await res.json();
      setResult(data.result);
    } catch {
      setResult({ error: 'Failed to fetch result' });
    } finally {
      setLoading(false);
    }
  }

  return (
    <div className="p-4 border border-white/10 rounded-lg bg-black/30">
      <label className="block mb-2 text-sm font-medium">Enter Fibonacci Number:</label>
      <input
        type="number"
        value={number}
        onChange={(e) => setNumber(e.target.value)}
        className="px-3 py-2 rounded bg-zinc-900 border border-zinc-700 text-white w-full mb-3"
      />

      <button
        onClick={calculateFibonacci}
        disabled={loading}
        className="bg-emerald-600 hover:bg-emerald-700 disabled:bg-gray-700 text-white px-4 py-2 rounded font-medium"
      >
        {loading ? 'Calculating...' : 'Run Worker'}
      </button>

      {result && (
        <div className="mt-4 text-sm text-gray-300">
          <p>🧮 Result: <b>{result.result}</b></p>
          <p>🧠 Thread ID: {result.threadId}</p>
        </div>
      )}
    </div>
  );
}

Usage

// Reuse worker threads for any CPU-heavy task
const { runWorker } = require('./src/services/workerService');
const path = require('path');

(async () => {
  const result = await runWorker({
    workerPath: path.resolve(__dirname, './src/worker.js'),
    workerData: 35
  });
  console.log('Worker Result:', result);
})();