System Atlas
the atlas

Concurrency is not parallelism

Dealing with many things at once is a different idea from doing many things at once.

the gist

Concurrency is about structure — composing a program so many tasks can be in progress at once by interleaving them. Parallelism is about execution — literally running tasks simultaneously on multiple cores. A single core can be concurrent but never parallel, which is why the two ideas need different names.

ANALOGY // A coffee shop with one barista who starts a second order while the first drink brews is concurrent; adding a second barista so two drinks are pulled at the exact same moment is parallel.
living diagram01 / 05
Concurrency on 1 coreinterleaving works
Parallelism on 1 coreimpossible
Concurrency = structurecompose many tasks
Parallelism = executionsame instant, many cores
Concurrency for I/O-boundoverlap the waiting
Parallelism for CPU-boundsplit the compute
Structure versus execution — two separate axes.
01

Two questions, not one

Concurrency answers 'how is the work structured so many tasks can make progress?' while parallelism answers 'how many tasks physically execute at the same instant?' They get conflated because a well-structured concurrent program often runs in parallel, but they are independent properties. Naming them separately is what lets you reason about design and hardware apart from each other.

02

One core can be concurrent

A single CPU core running one instruction stream can still handle many tasks by rapidly switching between them — start task A, pause it while it waits, run task B, come back. This is concurrency without any parallelism: at no single instant are two tasks truly running together. The illusion of simultaneity comes from switching faster than a human can perceive.

03

Parallelism needs real hardware

True parallelism requires multiple execution units — several cores, CPUs, or machines — so two tasks occupy the same tick of the clock. You cannot get parallelism from a single core no matter how you structure the code; you can only get concurrency. Parallelism is therefore bounded by the hardware you actually have, while concurrency is bounded only by how you design.

04

I/O-bound favors concurrency

When work spends most of its time waiting — on network calls, disk reads, or a database — a single core can stay busy by overlapping many waits. Async I/O and event loops shine here: while one request awaits a response, the core services thousands of others. Adding cores barely helps because the bottleneck is waiting, not computing.

05

CPU-bound favors parallelism

When work is pure computation — resizing images, training a model, hashing — the core is never idle, so interleaving buys nothing. The only way to go faster is to split the work across multiple cores and run the pieces genuinely at once. Here concurrency alone stalls and real parallelism is the lever that matters.

the full picture
01

Why the distinction matters

"Concurrency is not parallelism" is a slogan popularised by Rob Pike, and it is one of those clarifications that quietly reorganises how you think about programs. In everyday speech the two words are synonyms — both suggest "many things at the same time" — but in systems they describe two genuinely different properties, and confusing them leads to bad designs: throwing cores at a problem that needs better structure, or over-engineering a structure for a problem that needs more cores.

The clean split is this. Concurrency is about *dealing* with many things at once — it is a property of how you structure a program so that multiple tasks can be in progress and make forward progress over the same period. Parallelism is about *doing* many things at once — it is a property of execution, where multiple tasks literally run at the same physical instant. One is about composition and design; the other is about hardware and simultaneous execution. Holding them apart is the whole lesson.

02

Concurrency: a way of structuring work

Concurrency is fundamentally a design idea. A concurrent program is decomposed into independently executing tasks — goroutines, coroutines, async functions, threads — that can be paused and resumed, so that while one is blocked or waiting, another can run. Whether they ever run at the same instant is a separate question entirely.

The classic proof is a single CPU core. Give one core several tasks and it can interleave them: run a slice of task A, pause it when it awaits something, switch to task B, and so on, switching far faster than a human can notice. To the outside world all the tasks appear to progress together, yet at no single tick of the clock are two of them actually executing — the core runs exactly one instruction stream. This is concurrency with zero parallelism, and it is completely real and useful. Concurrency, then, is bounded only by how cleverly you compose the work; it does not depend on how many cores you own.

03

Parallelism: a property of execution

Parallelism is about the physical machine. Two tasks are parallel when they occupy the same moment of wall-clock time on separate execution units — two cores, two CPUs, two GPUs, or two machines. Parallelism is therefore hard-limited by hardware: on a single core you can never achieve it, no matter how you write the code, because there is only one thing physically executing at a time.

The relationship between the two is one-directional and worth stating precisely. Concurrency *enables* parallelism but does not *require* it: if you have structured your program as independent tasks (a concurrent design), a runtime can spread those tasks across multiple cores and they will run in parallel. But you can also have concurrency with no parallelism (single core, interleaved) — and, more subtly, parallelism is only possible because the work was decomposable in the first place. As Pike put it, concurrency is about *dealing* with lots of things at once; parallelism is about *doing* lots of things at once. Good concurrent structure is what lets the scheduler cash in whatever parallel hardware happens to be available.

04

I/O-bound versus CPU-bound — the deciding factor

The practical question is which one your problem actually needs, and the answer almost always turns on whether the work is I/O-bound or CPU-bound.

  • I/O-bound work spends most of its time *waiting* — on a network response, a disk read, a database query. Here concurrency is the win, and you may not need parallelism at all. A single-threaded event loop (Node.js, Python's asyncio, Go's scheduler) can juggle tens of thousands of connections on one core, because while one request is blocked on I/O the core does useful work for others. The bottleneck is idle waiting, and overlapping the waits is exactly what concurrency provides.
  • CPU-bound work spends its time *computing* — resizing images, crunching numbers, hashing, model inference. The core is never idle, so interleaving tasks buys nothing; you are just time-slicing a fully busy resource. The only way to go faster is genuine parallelism: split the computation across multiple cores so the pieces execute at once. This is what thread pools, multiprocessing, and SIMD/GPU work are for.

A useful mental shortcut: reach for concurrency to hide latency, and for parallelism to increase throughput on compute.

05

How this shows up in real systems

Most serious systems use both, deliberately. A web server is concurrent by nature — thousands of requests in flight — and it typically runs a pool of workers so that concurrency is realised in parallel across all available cores: concurrency for the structure, parallelism for the throughput. Go's runtime multiplexes many concurrent goroutines onto a smaller set of OS threads and cores; a browser keeps the UI responsive with an async event loop (concurrency) while offloading heavy work to Web Workers on other cores (parallelism).

The engineering judgment is diagnosing your bottleneck before choosing a tool. If your service is slow because it waits on downstream calls, adding cores is wasted money — you need a concurrent, async structure to overlap the waits. If it is slow because it is pinned at 100% CPU on one core, no amount of clever async will help — you need to parallelise across cores. Getting this diagnosis right is the difference between an architecture that scales and one that just burns hardware. And underneath it all sits the same truth: concurrency is how you design, parallelism is how it runs, and they are not the same thing.

what to remember
01

Concurrency = dealing with many tasks at once by interleaving them; it's a way of structuring a program.

02

Parallelism = doing many tasks at the same instant on multiple cores; it's a way of executing them.

03

A single core can be concurrent (rapid task-switching) but not truly parallel.

04

Concurrency shines for I/O-bound work: overlap waiting on network or disk with useful work.

05

Parallelism shines for CPU-bound work: split a heavy computation across cores to finish faster.

06

A concurrent design can run in parallel when hardware allows — concurrency enables parallelism but doesn't require it.

check yourself

Quick quiz

Q1

Can a single-core machine be concurrent?

Q2

Which workload benefits most from adding more cores?

follow the thread