---
topic: dev-practices
author: Crashtech Editorial
published: Nov 13, 2026 · read: 3 min
---

Concurrency Is Not Parallelism, and Mixing Them Up Costs You

Concurrency is about structuring work that overlaps. Parallelism is about running it at the same instant on multiple cores. Confusing them leads to wrong fixes.

– –

A team adds a thread pool to speed up an endpoint that spends 95 percent of its time waiting on a database. Nothing gets faster, and now there are race conditions. A different team runs a CPU-heavy job on a single async event loop and wonders why one request freezes everything. Both teams mixed up two ideas that sound alike.

Two different questions

Concurrency how is the work structured?
Many tasks are in progress during overlapping periods. A single CPU core can do it by switching between tasks, usually when one blocks on I/O. It is a property of your program’s design.
Parallelism how is the work executed?
Several tasks are literally running at the same instant, on different cores or machines. It is a property of the execution, and it needs hardware that can do it.

A good analogy: one barista juggling five orders (steaming milk while the espresso pulls) is concurrency. Five baristas each making one coffee is parallelism. A coffee shop can have either, or both.

I/O-bound versus CPU-bound decides everything

Work is mostly…Time goes toWhat helpsWhy
I/O-boundWaiting on network, disk, databaseConcurrency (async, event loop, many lightweight tasks)While one task waits, another runs
CPU-boundComputingParallelism (multiple cores, processes)More computation per second needs more cores

An async web server serving 10,000 idle connections on one thread is the poster child for concurrency without parallelism. A video encoder splitting frames across 16 cores is parallelism with little concurrency design at all.

The event loop trap

Single-threaded async runtimes get their concurrency from tasks that yield while waiting. A long CPU loop never yields, so every other task stalls behind it. Push CPU-heavy work to worker threads or processes and keep the loop for waiting.

Advertisement

Why parallel speedup has a ceiling

Parallelism is limited by whatever part of the job cannot be split. Amdahl’s law states it plainly: if a fraction p of the work is parallelizable across n workers, the maximum speedup is

speedup = 1 / ( (1 - p) + p / n )

If 90 percent of your job parallelizes (p = 0.9), 8 cores give about 4.7x, and even infinite cores cap at 10x, because the serial 10 percent never shrinks. Before buying cores, look for the serial part: a single lock, one shared queue, a final merge step.

Where they work together

Real systems combine both. A web server runs several worker processes (parallelism across cores), and each worker handles many connections concurrently with an event loop. A well-designed concurrent program also scales onto more cores when you need it, because its tasks were already independent.

Language runtimes shape your choices

  • Event-loop runtimes (Node.js, Python asyncio): excellent concurrency, parallelism via workers or extra processes.
  • Goroutine-style runtimes: cheap tasks scheduled across multiple cores automatically.
  • Standard CPython threads: concurrency for I/O, but the global interpreter lock prevents parallel Python bytecode, so CPU-bound parallelism needs processes or native code.

Do

Profile first and classify the bottleneck: waiting or computing. Pick overlap (concurrency) for waiting and more workers (parallelism) for computing.

Don't

Add threads to an I/O-bound path or blocking calls to an async path. Both change the code and leave latency where it was.

Takeaway

Concurrency is about dealing with many things at once, parallelism is about doing many things at once. They answer different bottlenecks. Name the bottleneck, then choose the tool, and remember that the serial fraction always sets the ceiling.

Advertisement

Frequently asked questions

Can I have concurrency without parallelism?

Yes. A single-threaded event loop handles thousands of connections concurrently by switching to another task whenever one waits on I/O. Only one task runs at any instant, so there is no parallelism, yet many tasks make progress in overlapping time. That is concurrency by structure, not by hardware.

When does adding threads or cores actually speed things up?

When the work is CPU-bound and can be split into independent pieces: image processing, number crunching, compression. For I/O-bound work, where time goes to waiting on networks or disks, more cores barely help. You need to overlap the waiting, which is a concurrency problem.

What is Amdahl's law?

It says the speedup from parallelizing is limited by the part that stays serial. With parallel fraction p on n workers, speedup is 1 divided by (1 minus p plus p over n). If 10 percent of the work is serial, no number of cores can make it more than 10 times faster.

Why do Python threads not speed up CPU-heavy code?

In standard CPython, the global interpreter lock lets only one thread execute Python bytecode at a time, so threads give concurrency for I/O but not parallel CPU work. For CPU-bound Python you typically use multiple processes, native extensions that release the lock, or a different runtime.

Sources & further reading

/* Comments */