Concurrency vs Parallelism: Understanding the Difference with Examples day 54 of system design

Concurrency and parallelism are two of the most misunderstood concepts in system design.

While they might sound similar, they refer to fundamentally different approaches to handling tasks.

Simply put:

• Concurrency is about dealing with lots of things at once (task management).




• Parallelism is about doing lots of things at once (task execution).

In this article, we’ll break down the differences, explore how they work, and walk through real-world applications with examples and code.

1. What is Concurrency?

Concurrency means an application is making progress on more than one task at the same time.

Even though a single CPU core can only execute one task at a time, it achieves concurrency by rapidly switching between tasks (context switching).

For example:

• Playing music while writing code.




• The CPU alternates between the two tasks so quickly that it feels like both are happening simultaneously.

But remember: this is not parallelism. This is concurrency.

Real-World Examples

Web Browsers: Rendering pages, fetching resources, responding to clicks.

• Web Servers: Handling multiple requests at the same time.




• Chat Apps: Sending/receiving messages, updating the UI.




• Video Games: Rendering, physics, input handling, background music.

Code Example: Concurrency in Python (asyncio)

import asyncio



async def task(name):

    for i in range(1, 4):

        print(f"{name} - Step {i}")

        await asyncio.sleep(0.5)  # simulate I/O work



async def main():

    await asyncio.gather(

        task("Task A"),

        task("Task B"),

        task("Task C"),

    )



asyncio.run(main())

Output (interleaved execution):

Task A - Step 1

Task B - Step 1

Task C - Step 1

Task A - Step 2

Task B - Step 2

Task C - Step 2

...

1. What is Parallelism?

Parallelism means multiple tasks are executed at the exact same time.

This requires multiple CPU cores or processors. Each task (or subtask) gets its own execution unit.

Real-World Examples

• Machine Learning Training: Distribute dataset batches across GPUs.




• Video Rendering: Multiple frames processed simultaneously.




• Web Crawlers: Fetch URLs in parallel.




• Big Data: Distribute jobs across a cluster.




• Scientific Simulations: Weather modeling, physics simulations.

Code Example: Parallelism in Python (multiprocessing)

from multiprocessing import Pool

import time



def work(n):

    print(f"Processing {n}")

    time.sleep(1)  # simulate CPU work

    return n * n



if __name__ == "__main__":

    numbers = [1, 2, 3, 4]



    with Pool(processes=4) as pool:  # use 4 CPU cores

        results = pool.map(work, numbers)



    print("Results:", results)

Output (executed in parallel):

Processing 1

Processing 2

Processing 3

Processing 4

Results: [1, 4, 9, 16]

Here, each task runs on a separate CPU core at the same time.

1. Concurrency vs Parallelism: Putting It All Together

• Concurrent, Not Parallel: Single-core CPU rapidly switching tasks.




• Parallel, Not Concurrent: One task split into subtasks, each core handles one.




• Neither: Sequential execution, one task at a time.




• Both: Multi-core CPU handling multiple concurrent tasks, each split into parallel subtasks.

Final Thoughts

Concurrency = task management (making progress on many things).

Parallelism = task execution (doing many things simultaneously).

Most modern systems use both together for efficiency.

Understanding these concepts helps you design scalable, efficient software — whether you're writing backend servers, training ML models, or building real-time apps.