Concurrency and parallelism look similar in both Korean and English, so they are often used interchangeably.
Even when CPUs had only one core, computers could play music while editing documents. How could a machine that physically handled only one thing at a time do several things “simultaneously”?
If you can answer that, you already understand the distinction. If not, this article will clarify exactly that point.
The same applies to names such as Swift Concurrency and GCD (Grand Central Dispatch) concurrent queues. This distinction is the foundation for understanding them correctly.
Here is the key summary.
- Concurrency: a logical structure for handling multiple tasks by progressing through them in turns.
- Parallelism: multiple tasks executing physically at the same time. A hardware concern.
- Concurrency is possible on a single core. Parallelism requires multiple cores.
- Code creates the concurrency structure; parallelism is the result of hardware taking advantage of it.
Understanding It with One Coffee Machine
Imagine a café with one barista (one core).
Two orders arrive. While extracting espresso for customer A, the barista heats milk for customer B; when extraction finishes, they finish A’s drink and return to B. Both orders are “in progress at the same time,” but at any instant the barista is doing only one thing.
That is concurrency: splitting work into small pieces, switching between them, and handling multiple tasks together.
Hire another barista (two cores), and the two orders are now actually prepared at the same time. That is parallelism.
The important point is this: even with one barista, the operating model of alternating between orders works. With two, the same model expands into physical simultaneous execution.
Translating It to Computers
Single-core multitasking was exactly a one-barista café.
The operating system assigned CPU time to one process and then another in turns, in units of tens of milliseconds (time slicing). To people, music playback and document editing therefore appeared to run simultaneously.
Multicore systems added parallelism. Now four cores can really execute four threads at the same time.
So let’s summarize the relationship this way.
- Parallelism without concurrency: running unrelated tasks, one per core
- Concurrency without parallelism: single-core time slicing
- Concurrency + parallelism: the foundation of modern computing, with multiple cores dividing up split tasks
The title of a famous talk by Rob Pike, creator of Go, summarizes this distinction in one sentence.
“Concurrency is not parallelism.”
He distinguished concurrency as “dealing with” multiple things and parallelism as “doing” multiple things.
What the Name Swift Concurrency Means
From this perspective, Apple’s choice to call its async/await model Swift “Concurrency” is precise.
async/await, Task, and actor are all tools for expressing how to split work, where to suspend it, and in what order to resume it. In other words, they are language constructs for designing concurrency.
The runtime and system scheduler decide how many cores actually execute that structure in parallel. Developers declare the structure (concurrency), while the system handles parallel execution.
async let a = fetchProfile() // Declare a structure that can ‘make progress concurrently’
async let b = fetchFeed()
let result = try await (a, b) // The system decides whether it runs in parallelEven if you create 100 tasks with TaskGroup, with eight cores at most eight run at the same time. The rest proceed in turns. Within a concurrency structure, parallelism is limited by the hardware.
In One Sentence for Interviews
“Concurrency is a logical structure for handling multiple tasks together by progressing through them in turns, whereas parallelism means multiple tasks execute physically at the same time. Therefore, concurrency is possible on a single core, but parallelism is not.”
It is also useful to prepare for follow-up questions: “How did single-core multitasking work?” (time slicing), and “Does concurrent code always run in parallel?” (No, the scheduler decides).
Summary
- Concurrency splits work into pieces, progresses through them in turns, and handles multiple tasks together. It is a logical concept.
- Parallelism means multiple tasks execute physically at the same time. It is a hardware-level concept.
- Concurrency (time slicing) is possible on a single core, but parallelism is not.
- Rob Pike: concurrency is “dealing with” multiple things; parallelism is “doing” multiple things.
- Swift Concurrency is a tool for declaring concurrency structures; the system decides the actual parallel execution.
- Coffee-machine analogy: one barista alternating between orders is concurrency; two baristas making them together is parallelism