Q043. What is the difference between concurrency and parallelism?

Short Answer

Concurrency means multiple activities can make progress during overlapping periods; parallelism means multiple activities execute at the same instant on different processing resources. A single-threaded async runtime is concurrent but not CPU-parallel. A multi-threaded workload may be both. Concurrency is primarily a program structure and coordination problem, while parallelism is an execution and throughput property.

Deep Dive

Concurrent code divides work into independently progressing units and defines how they communicate, wait, and cancel. The scheduler may interleave those units on one thread. This is valuable for I/O-bound servers because one task can run while another waits for a socket or timer.

Parallel code executes work simultaneously, usually on multiple cores. This can reduce latency or increase throughput for CPU-bound work, but it introduces synchronization, partitioning, and load-balancing costs.

Async Rust provides concurrency but does not automatically make CPU-heavy work parallel. Tokio's multi-thread runtime can schedule independent ready tasks on several workers, but blocking or CPU-intensive work still needs deliberate isolation and often a CPU-oriented pool such as Rayon.

Internal Model

An OS scheduler time-slices runnable threads and may place them on different cores. An async executor polls ready tasks; a task that returns Pending yields its worker until a wake-up schedules it again.

Whether work is parallel depends on how many executor workers or OS threads are actually running and whether the work can proceed independently.

Example

use std::thread;
use std::time::Duration;

fn main() {
    let first = thread::spawn(|| {
        thread::sleep(Duration::from_millis(10));
        20
    });
    let second = thread::spawn(|| 22);

    assert_eq!(first.join().unwrap() + second.join().unwrap(), 42);
}

Common Mistakes

• Using concurrency and parallelism as synonyms.
• Assuming async code always uses multiple CPU cores.
• Running CPU-bound loops as ordinary async tasks and expecting improved throughput.

Follow-ups

• Can concurrent code run on one OS thread?
• When should CPU-bound work use Rayon instead of Tokio?
• How do contention and false sharing limit parallel speedup?

Related

• Q044. How does an OS thread differ from an async task?
• Q061. What is the relationship between a future, a task, and an executor?
• Q071. Why is blocking code dangerous inside async tasks?

References

• Rust Standard Library
• Async Book
• Tokio Documentation