Concurrency and Parallel Programming Patterns Cheat Sheet

Updated 2026-05-28

Next Topic: Contract Testing Cheat Sheet

🧠Study flashcards on this topic91 cards · spaced repetition→

Concurrency is the ability to execute multiple tasks in overlapping time periods, while parallelism executes multiple tasks simultaneously on multiple cores or processors. These concepts are fundamental to building performant, responsive software systems that leverage modern multi-core hardware. The key challenge lies not in spawning threads or processes, but in coordinating their access to shared resources without introducing subtle, hard-to-reproduce bugs. Understanding the distinction between concurrency models (threads, processes, coroutines, virtual threads), synchronization primitives (mutexes, semaphores, barriers), and common pitfalls (race conditions, deadlocks, false sharing) transforms concurrent programming from an intimidating minefield into a structured engineering discipline with predictable trade-offs and proven patterns.

What This Cheat Sheet Covers

This topic spans 11 focused tables and 92 indexed concepts, 91 flashcards. Below is a complete table-by-table outline of this topic, spanning foundational concepts through advanced details.

Table 1: Concurrency ModelsTable 2: Synchronization PrimitivesTable 3: Common Concurrency BugsTable 4: Parallel Programming PatternsTable 5: Lock-Free Programming ConceptsTable 6: Memory and OrderingTable 7: Async and Reactive PatternsTable 8: Thread Coordination TechniquesTable 9: Performance and ScalabilityTable 10: Concurrency Control StrategiesTable 11: Common Antipatterns and Fixes

Quick IndexSubscribe to unlock

A jump-to index of every table row in this cheat sheet.

Mind MapSubscribe to unlock

An interactive map of every table and concept in this topic.

Table 1: Concurrency Models

Concurrency and parallelism are realized through a variety of execution units — each with different scheduling, memory, and overhead characteristics. Choosing the right model up-front determines everything from thread-safety surface area to scalability ceiling.

Model	Example	Description
Thread	`std::thread t(func);` `t.join();`	• OS-managed execution unit sharing process memory space • preemptively scheduled by kernel • ~1MB stack overhead per thread • suitable for CPU-bound parallel work.
Process	`fork()` in Unix `multiprocessing.Process()` in Python	• Independent execution unit with separate memory space • isolated from other processes • higher creation/context-switch cost • communicates via IPC • avoids shared-memory race conditions.
Coroutine	`async def fetch():` `await http.get(url)`	• Cooperatively-scheduled function that can suspend and resume execution • lightweight (~KB overhead) • ideal for I/O-bound tasks • requires explicit yield points • avoids preemption overhead.
Goroutine	`go func() { ... }()`	• Go's lightweight threads managed by Go runtime • multiplexed onto OS threads (M:N model) • starts with 2KB stack that grows dynamically • extremely cheap to spawn thousands.
Virtual Thread	`Thread.startVirtualThread(` `() -> blockingOp());` `Executors.newVirtualThreadPerTaskExecutor()`	• JVM-managed lightweight thread (Java 21+, JEP 444) that unmounts from its OS carrier thread during blocking • millions can run concurrently on modest hardware • enables thread-per-task style without reactive complexity for I/O-bound workloads
Actor Model	Akka, Erlang OTP	• Message-passing concurrency where actors are isolated units that communicate via asynchronous messages • no shared state • inherently avoids many concurrency bugs • scales naturally to distributed systems.
Event Loop	Node.js, JavaScript async	• Single-threaded with non-blocking I/O • events processed sequentially from queue • eliminates race conditions but CPU-bound tasks block entire loop • combines with async/await for readability.
Green Thread	Erlang processes, early Java threads	• User-space threads scheduled by runtime/VM rather than OS • many-to-one or many-to-many mapping to OS threads • lower overhead but cannot utilize multiple cores without runtime support.
Fiber	`boost::fiber` in C++ `CreateFiber()` in Windows	• User-mode cooperative scheduling primitive • explicit context switching • ultra-lightweight • useful for high-concurrency scenarios like game engines or network servers.

Table 2: Synchronization Primitives

These low-level building blocks govern access to shared memory between concurrent threads. Choosing the wrong primitive — or holding it too long — directly causes deadlocks, starvation, or performance collapse.

Primitive	Example	Description
Mutex (Mutual Exclusion)	`std::mutex m;` `m.lock();` `/* critical section */` `m.unlock();`	• Ensures only one thread holds lock at a time • owned by locking thread • reentrant variants allow same thread to lock multiple times • fundamental building block for protecting shared data.

The rest of this section is part of the full cheat sheet

Table 3: Common Concurrency Bugs

Concurrency bugs are notoriously hard to reproduce because their timing-dependent nature means they pass in testing but surface under load. Knowing their signatures — not just their names — is the fastest path to diagnosis and prevention.

Bug	Example	Description
Race Condition	`if (x == 0) { y = 1/x; }` executed by two threads	• Outcome depends on unpredictable timing of thread execution • non-deterministic behavior • may pass testing but fail in production under load • fixed with proper synchronization.

The rest of this section is part of the full cheat sheet

Table 4: Parallel Programming Patterns

These patterns structure how work is divided, distributed, and collected across concurrent workers. The best choice depends on whether work is compute-bound, I/O-bound, irregular in size, or flows through transformation stages.

Pattern	Example	Description
Thread Pool	`ThreadPoolExecutor(core=4, max=8)` Submit tasks to pool	• Reuses fixed threads to execute many tasks • amortizes thread creation cost • bounds concurrency level • includes task queue for overflow • prevents thread explosion.

The rest of this section is part of the full cheat sheet

Table 1: Concurrency Models

Model	Example	Description
Thread	`std::thread t(func);` `t.join();`	• OS-managed execution unit sharing process memory space • preemptively scheduled by kernel • ~1MB stack overhead per thread • suitable for CPU-bound parallel work.
Process	`fork()` in Unix `multiprocessing.Process()` in Python	• Independent execution unit with separate memory space • isolated from other processes • higher creation/context-switch cost • communicates via IPC • avoids shared-memory race conditions.
Coroutine	`async def fetch():` `await http.get(url)`	• Cooperatively-scheduled function that can suspend and resume execution • lightweight (~KB overhead) • ideal for I/O-bound tasks • requires explicit yield points • avoids preemption overhead.
Goroutine	`go func() { ... }()`	• Go's lightweight threads managed by Go runtime • multiplexed onto OS threads (M:N model) • starts with 2KB stack that grows dynamically • extremely cheap to spawn thousands.
Virtual Thread	`Thread.startVirtualThread(` `() -> blockingOp());` `Executors.newVirtualThreadPerTaskExecutor()`	• JVM-managed lightweight thread (Java 21+, JEP 444) that unmounts from its OS carrier thread during blocking • millions can run concurrently on modest hardware • enables thread-per-task style without reactive complexity for I/O-bound workloads
Actor Model	Akka, Erlang OTP	• Message-passing concurrency where actors are isolated units that communicate via asynchronous messages • no shared state • inherently avoids many concurrency bugs • scales naturally to distributed systems.
Event Loop	Node.js, JavaScript async	• Single-threaded with non-blocking I/O • events processed sequentially from queue • eliminates race conditions but CPU-bound tasks block entire loop • combines with async/await for readability.
Green Thread	Erlang processes, early Java threads	• User-space threads scheduled by runtime/VM rather than OS • many-to-one or many-to-many mapping to OS threads • lower overhead but cannot utilize multiple cores without runtime support.
Fiber	`boost::fiber` in C++ `CreateFiber()` in Windows	• User-mode cooperative scheduling primitive • explicit context switching • ultra-lightweight • useful for high-concurrency scenarios like game engines or network servers.

Table 2: Synchronization Primitives

Primitive	Example	Description
Mutex (Mutual Exclusion)	`std::mutex m;` `m.lock();` `/* critical section */` `m.unlock();`	• Ensures only one thread holds lock at a time • owned by locking thread • reentrant variants allow same thread to lock multiple times • fundamental building block for protecting shared data.

Table 3: Common Concurrency Bugs

Bug	Example	Description
Race Condition	`if (x == 0) { y = 1/x; }` executed by two threads	• Outcome depends on unpredictable timing of thread execution • non-deterministic behavior • may pass testing but fail in production under load • fixed with proper synchronization.

Table 4: Parallel Programming Patterns

Pattern	Example	Description
Thread Pool	`ThreadPoolExecutor(core=4, max=8)` Submit tasks to pool	• Reuses fixed threads to execute many tasks • amortizes thread creation cost • bounds concurrency level • includes task queue for overflow • prevents thread explosion.