Web Workers

Published by Brayan K

A Web Worker is a script that runs on a separate background thread, communicating with the main thread only by passing messages, so heavy computation can run without freezing the user interface.

Part of the free JavaScript course at LearnCodingFast — hands-on lessons with examples you run in your browser, plus practice exercises and a quick quiz.

Move a calculation across a real execution boundary

A dedicated worker has its own global environment and event loop. It cannot read the page’s DOM directly. Send a small request, compute there and return a result that the page decides how to display. Worker startup and data transfer have costs, so a tiny calculation is a teaching fixture here, not a performance recommendation.

// This source belongs to the worker, not to the page.
const source = 'self.onmessage = event => self.postMessage({ square: event.data * event.data, dom: typeof document });';
const url = URL.createObjectURL(new Blob([source], { type: "text/javascript" }));
const worker = new window.Worker(url);
try {
  // Install observers before sending the request.
  const reply = new Promise((resolve, reject) => {
    worker.onmessage = event => resolve(event.data);
    worker.onerror = event => { event.preventDefault(); reject(new Error("worker failed")); };
  });
  worker.postMessage(3);
  console.log(JSON.stringify(await reply));
} finally {
  worker.terminate();
  URL.revokeObjectURL(url);
}

// ✅ Expected output:
// {"square":9,"dom":"undefined"}

These are actual browser workers created from local Blob URLs, with no external server request. A production application often uses a separate worker module resolved by its bundler. Module Bundlers: Webpack, Parcel, Vite (Overview) owns asset URLs and emitted bundles. A worker has some browser APIs, but not window or document.

Messages clone ordinary data unless ownership is transferred

const url = URL.createObjectURL(new Blob(['self.onmessage = event => self.postMessage(event.data);'], { type: "text/javascript" }));
const worker = new window.Worker(url);
try {
  const reply = new Promise(resolve => { worker.onmessage = event => resolve(event.data); });
  const input = { nested: { count: 2 } };
  worker.postMessage(input);
  input.nested.count = 9;
  const received = await reply;
  console.log(received.nested.count, input.nested.count, received === input);
} finally { worker.terminate(); URL.revokeObjectURL(url); }

// ✅ Expected output:
// 2 9 false
const source = 'self.onmessage = event => { const buffer = event.data; const sum = [...new Uint8Array(buffer)].reduce((a,b) => a+b,0); self.postMessage({ sum, buffer }, [buffer]); };';
const url = URL.createObjectURL(new Blob([source], { type: "text/javascript" }));
const worker = new window.Worker(url);
try {
  const reply = new Promise(resolve => { worker.onmessage = event => resolve(event.data); });
  const bytes = new Uint8Array([2, 4, 6]);
  worker.postMessage(bytes.buffer, [bytes.buffer]);
  console.log(bytes.byteLength);
  const result = await reply;
  console.log(result.sum, result.buffer.byteLength, [...new Uint8Array(result.buffer)].join(", "));
} finally { worker.terminate(); URL.revokeObjectURL(url); }

// ✅ Expected output:
// 0
// 12 3 2, 4, 6

The typed-array view refers to a buffer whose ownership moved; it is not a second shared mutable copy. Here the worker transfers that buffer back in its reply. Deep Copy vs Shallow Copy & Data Structures owns structured cloning and transfer semantics beyond workers. SharedArrayBuffer is a separate shared-memory mechanism with cross-origin-isolation requirements; the introduction’s message-only description covers the ordinary model used in this lesson, not that exception.

const url = URL.createObjectURL(new Blob(['self.onmessage = event => self.postMessage(event.data);'], { type: "text/javascript" }));
const worker = new window.Worker(url);
try {
  try { worker.postMessage(() => 3); }
  catch (error) { console.log(error.name); }
} finally { worker.terminate(); URL.revokeObjectURL(url); }

// ✅ Expected output:
// DataCloneError

Send data describing a job, not a callback to execute. DOM nodes, functions and many behavior-bearing objects do not cross this boundary as ordinary cloned data. Class prototypes and methods are not an RPC protocol.

A cancellation message waits behind the current worker task

const source = 'self.onmessage = event => { if (event.data === "start") { let sum = 0; for (let i=1;i<=1000;i++) sum += i; self.postMessage("done " + sum); } else if (event.data === "cancel") self.postMessage("cancel handled"); };';
const url = URL.createObjectURL(new Blob([source], { type: "text/javascript" }));
const worker = new window.Worker(url);
try {
  const replies = new Promise(resolve => {
    const values = [];
    worker.onmessage = event => { values.push(event.data); if (values.length === 2) resolve(values); };
  });
  worker.postMessage("start");
  worker.postMessage("cancel");
  console.log((await replies).join(", "));
} finally { worker.terminate(); URL.revokeObjectURL(url); }

// ✅ Expected output:
// done 500500, cancel handled

Both requests are real messages. The tiny finite loop deliberately avoids freezing the browser, while showing that a later message cannot interrupt the task currently executing. Cooperative cancellation requires chunking so the worker can receive new messages. terminate stops the worker abruptly and does not promise to run pending finally blocks.

A worker keeps CPU work off the page thread, but a large cloned payload or expensive result rendering can still stall the page. JavaScript Performance Optimization Techniques owns measurement and chunking. AbortController & Cancelling Async Work owns cooperative signals; passing a signal-shaped object is not automatically a worker cancellation protocol.

Treat replies as protocol messages with identity and failure paths

const source = 'self.onmessage = event => self.postMessage({ id: event.data.id, result: event.data.value * 2 });';
const url = URL.createObjectURL(new Blob([source], { type: "text/javascript" }));
const worker = new window.Worker(url);
try {
  const reply = new Promise(resolve => { worker.onmessage = event => resolve(event.data); });
  worker.postMessage({ id: 7, value: 4 });
  console.log(JSON.stringify(await reply));
} finally { worker.terminate(); URL.revokeObjectURL(url); }

// ✅ Expected output:
// {"id":7,"result":8}
const url = URL.createObjectURL(new Blob(['throw new Error("worker example failed");'], { type: "text/javascript" }));
const worker = new window.Worker(url);
try {
  const failure = await new Promise(resolve => {
    worker.addEventListener("error", event => {
      event.preventDefault();
      resolve(event.message);
    }, { once: true });
  });
  console.log(failure);
} finally { worker.terminate(); URL.revokeObjectURL(url); }

// ✅ Expected output:
// Uncaught Error: worker example failed

An error handler prevents a caller from waiting forever after a known crash. messageerror is a separate deserialization failure event. Neither event is a deadline for a worker that simply stops replying. Correlation IDs associate messages; they do not authenticate them. Dispose a worker and revoke its Blob URL when its owning feature ends.

Guided exercise: send a job and return its result

Fill the literal hints in the worker source and the page request. The returned number is produced in a real worker. The finally block releases both resources.

const source = 'self.onmessage = event => self.___(event.data * 3);'; // 👉 replace ___ with postMessage
const url = URL.createObjectURL(new Blob([source], { type: "text/javascript" }));
const worker = new window.___(url); // 👉 replace ___ with Worker
try {
  const reply = new Promise(resolve => { worker.onmessage = event => resolve(event.data); });
  worker.postMessage(___); // 👉 replace ___ with 4
  console.log(await reply);
} finally { worker.terminate(); URL.revokeObjectURL(url); }

// ✅ Expected output:
// 12

Brief: own one worker and at most one active calculation

Implement createSumWorker using the local worker source in the checked solution. run(values) accepts a dense array of at most 1000 integers with absolute value at most 10000; it resolves to the exact sum of their squares. Validate and snapshot inputs before sending. Empty input produces zero. Every request carries an increasing safe-integer ID.

Allow one pending job. Reject a new run with Error("worker busy") while occupied, and Error("worker disposed") after disposal; check these lifecycle states before validating the new input. Accept only the matching response ID and a successful non-negative safe-integer result. Ignore unrelated IDs. An invalid matching reply, error, messageerror or send failure closes the worker and rejects the pending job.

dispose is terminal and idempotent. Remove listeners, terminate the worker, revoke its Blob URL and reject a pending job exactly once. The frozen API does not freeze the worker’s lifecycle. The small protocol intentionally has no retry, queue, deadline or cooperative cancellation message. A nonresponsive worker remains pending until the caller disposes it.

function createSumWorker() {
  const source = "self.addEventListener(\"message\", event => {\n  const job = event.data;\n  if (!job || job.type !== \"sum\" || !Number.isSafeInteger(job.id) ||\n      !Array.isArray(job.values) || job.values.length > 1000 ||\n      job.values.some(value => !Number.isInteger(value) || Math.abs(value) > 10000)) return;\n  const result = job.values.reduce((total, value) => total + value * value, 0);\n  self.postMessage({ id: job.id, ok: true, result });\n});";
  const url = URL.createObjectURL(new Blob([source], { type: "text/javascript" }));
  let worker;
  try { worker = new window.Worker(url); }
  catch (error) { URL.revokeObjectURL(url); throw error; }
  let pending = null, closed = false, sequence = 0;
  function close(reason) {
    if (closed) return;
    closed = true;
    worker.removeEventListener("message", onMessage);
    worker.removeEventListener("error", onError);
    worker.removeEventListener("messageerror", onError);
    worker.terminate();
    URL.revokeObjectURL(url);
    if (pending) { const job = pending; pending = null; job.reject(reason); }
  }
  function onError(event) {
    event.preventDefault();
    close(new Error("worker failed"));
  }
  function onMessage(event) {
    if (!pending || event.data?.id !== pending.id) return;
    const reply = event.data;
    if (reply.ok !== true || !Number.isSafeInteger(reply.result) || reply.result < 0) {
      close(new Error("invalid worker response"));
      return;
    }
    const job = pending;
    pending = null;
    job.resolve(reply.result);
  }
  worker.addEventListener("message", onMessage);
  worker.addEventListener("error", onError);
  worker.addEventListener("messageerror", onError);
  return Object.freeze({
    async run(values) {
      if (closed) throw new Error("worker disposed");
      if (pending) throw new Error("worker busy");
      if (!Array.isArray(values) || values.length > 1000) throw new TypeError("invalid values");
      for (let i = 0; i < values.length; i++) {
        if (!Object.hasOwn(values, i) || !Number.isInteger(values[i]) || Math.abs(values[i]) > 10000) {
          throw new TypeError("invalid values");
        }
      }
      if (sequence === Number.MAX_SAFE_INTEGER) throw new RangeError("job limit reached");
      const copied = values.slice();
      const id = ++sequence;
      return new Promise((resolve, reject) => {
        pending = { id, resolve, reject };
        try { worker.postMessage({ type: "sum", id, values: copied }); }
        catch { close(new Error("worker send failed")); }
      });
    },
    dispose() { close(new Error("worker disposed")); }
  });
}
const service = createSumWorker();
try {
  const values = [2, -3, 4];
  const first = service.run(values);
  values[0] = 99;
  const busy = service.run([1]).catch(error => error.message);
  console.log(await first, await busy);
  console.log(await service.run([]));
  try { await service.run([1.5]); } catch (error) { console.log(error.name, error.message); }
} finally { service.dispose(); service.dispose(); }
try { await service.run([1]); } catch (error) { console.log(error.message); }

// ✅ Expected output:
// 29 worker busy
// 0
// TypeError invalid values
// worker disposed

Practice quiz

What does this complete program print? const input={n:2};const output=structuredClone(input);input.n=9;console.log(output.n,input.n);

  • 2 9
  • 9 9
  • 2 2
  • 9 2

Answer: 2 9. A structured clone has independent ordinary data.

What does transferring an ArrayBuffer to a worker do?

  • Creates a second shared writable copy
  • Moves ownership and detaches the sender’s buffer
  • Serializes it to JSON
  • Automatically transfers it back

Answer: Moves ownership and detaches the sender’s buffer. The transfer list moves ownership. The receiver must explicitly transfer it back if that is needed.

What does this complete program print? const buffer=new ArrayBuffer(4);const received=structuredClone(buffer,{transfer:[buffer]});console.log(buffer.byteLength,received.byteLength);

  • 4 4
  • 4 0
  • 0 4
  • 0 0

Answer: 0 4. The sender buffer is detached while the received buffer retains its bytes.

A worker is executing one long synchronous loop. When can it handle a newly posted cancellation message?

  • Immediately in the middle of any expression
  • Only after all browser tabs close
  • Whenever the page calls abort()
  • After the current worker task yields or finishes

Answer: After the current worker task yields or finishes. A message is queued on the worker event loop; it does not interrupt synchronous execution.

What does this complete program print? try{structuredClone(()=>3);}catch(error){console.log(error.name);}

  • DataCloneError
  • TypeError
  • undefined
  • Error

Answer: DataCloneError. Functions are not structured-cloneable message data.

What should the owner do when a worker-backed feature is disposed?

  • Leave pending callers waiting forever
  • Reject pending work and release listeners, worker and Blob URL
  • Only hide the page output
  • Assume every worker finally block runs

Answer: Reject pending work and release listeners, worker and Blob URL. Resource lifetime and promise settlement are separate responsibilities that both need cleanup.

What does this complete program print? const message={id:4,result:9};console.log(message.id===5,message.result);

  • true 9
  • false 4
  • false 9
  • true 4

Answer: false 9. A result belonging to a different request ID must not settle the current request.

Which statement describes this lesson’s small worker examples?

  • They prove every worker improves performance
  • They benchmark physical devices
  • They validate a live production worker host
  • They test real message behavior without claiming a speedup

Answer: They test real message behavior without claiming a speedup. The examples establish behavior in the tested browser, not a performance improvement for an unmeasured application.

Continue this course

Related lessons