Concurrency in JavaScript

1Concurrency vs Parallelism — the Distinction That Matters Here

• Parallelism: multiple things physically executing at the exact same instant (requires multiple CPU cores/threads).
• Concurrency: multiple things in progress over overlapping time periods, but not necessarily executing at the same instant.

JavaScript's main thread is single-threaded — it cannot achieve true parallelism for regular JS code. What it achieves is concurrency: interleaving many in-progress async operations on one thread, switching between them at await points and callback boundaries, coordinated by the event loop (see the Event Loop topic).

(A dedicated, deeper comparison of concurrency vs parallelism as general concepts is covered in the Advanced Engineering stack — this topic focuses specifically on how JS achieves concurrency without true parallel threads.)

2How Single-Threaded Concurrency Actually Works

async function taskA() {
  console.log("A: step 1");
  await delay(50);
  console.log("A: step 2");
}
async function taskB() {
  console.log("B: step 1");
  await delay(50);
  console.log("B: step 2");
}

taskA();
taskB();
// Output: A:1, B:1, (both waiting concurrently), A:2, B:2 (roughly together)

Neither task literally runs "at the same time" as the other — the engine runs taskA's synchronous part, then taskB's synchronous part, then both resume (via the microtask/macrotask queues) once their delay finishes. The appearance of simultaneity comes from interleaving, not literal parallel execution.

3Where JavaScript DOES Get Real Parallelism

The reason async I/O (file reads, network requests) doesn't block the main thread isn't magic — the actual waiting happens in the OS or runtime layer, outside JavaScript's single thread; JS only re-engages once a result is ready.

4Concurrency Enables Throughput, Not Raw Speed-Up of CPU Work

// This does NOT get faster with concurrency — it's pure CPU work,
// blocking the single thread regardless of how "async" it looks:
async function heavyComputation() {
  let sum = 0;
  for (let i = 0; i < 1e9; i++) sum += i; // still fully blocks the thread
  return sum;
}

Concurrency helps massively with I/O-bound work (waiting on network/disk — the thread is free to do other things while waiting) but does nothing for CPU-bound work (the thread is genuinely busy computing, with nothing to interleave). CPU-bound work needs real parallelism — Worker Threads / Web Workers — not async/await.

5A Practical Mental Model

I/O-bound task (network request, file read, timer)
  → mostly WAITING, not computing
  → concurrency (async/await) helps a lot — the thread is free during the wait

CPU-bound task (image processing, large sort, heavy math)
  → mostly COMPUTING, not waiting
  → concurrency does nothing — need real parallelism (Worker Threads)

Main thread:  Isolate A — heap A, GC runs independently, Context chain A
Worker thread: Isolate B — heap B, GC runs independently, Context chain B
                (genuinely separate engine instances, not just separate call stacks)

const worker = new Worker("worker.js");
worker.postMessage({ name: "Ana" }); // this object is NOT shared by reference

⚠️ Common Pitfalls

1. Believing async makes code run on another thread — it doesn't; async/await is entirely about scheduling on the same single thread, not multi-threading.
2. Expecting concurrency to speed up CPU-heavy loops — only real parallelism (Workers) helps here; wrapping a heavy loop in an async function changes nothing about its blocking behavior.
3. Assuming "concurrent" means "simultaneous" — in JS, concurrent tasks are interleaved on one thread, not literally running at the same instant (unless offloaded to Workers).
4. Not offloading genuinely heavy computation — a long synchronous loop inside an async function still freezes the event loop, blocking timers, network handling, and (in browsers) rendering, exactly as described in the Call Stack and Event Loop topics.

📋 Quick Reference

JS main thread: single-threaded, concurrency via interleaving (event loop)
True parallelism: Web Workers / Worker Threads only
I/O-bound work → concurrency (async/await) helps a lot
CPU-bound work  → concurrency does nothing, need real threads

🎤 Interview Q&A

🛠️ Practice exercises

Each exercise is a file in this topic folder. Code exercises are self-checking: run them and make the checks pass.

Source: js_concurrency_theory.md · generated by tools/build_lessons.py