Concurrency Models and Patterns Across Languages Cheat Sheet

Updated 2026-05-16

Next Topic: Functional Programming Cheat Sheet

🧠Study flashcards on this topic86 cards · spaced repetition→

Concurrency models define how programs handle multiple tasks simultaneously, whether through parallel execution on multiple cores or interleaved execution on a single core. Different programming languages adopt fundamentally different approaches — message passing (Go, Erlang), shared memory (Java, C++), async/await (JavaScript, Python), and ownership-based (Rust) — each optimized for different classes of problems. The landscape spans from low-level atomic operations and memory ordering to high-level abstractions like actors and CSP channels. Understanding these models is essential because the choice shapes performance, safety, and complexity: a lock-based approach may deadlock where a message-passing design cannot, and an async runtime may outperform threads for I/O-bound work while underperforming for CPU-bound tasks.

What This Cheat Sheet Covers

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

Table 1: Fundamental Concurrency ModelsTable 2: Language-Specific Threading ModelsTable 3: Synchronization PrimitivesTable 4: Atomic Operations and Memory OrderingTable 5: Lock-Free and Wait-Free ProgrammingTable 6: Concurrency PatternsTable 7: Deadlock and LivelockTable 8: Async Runtimes and Event LoopsTable 9: Concurrency Bugs and TestingTable 10: Context Switching and PerformanceTable 11: Message Passing vs Shared MemoryTable 12: Concurrency Best Practices

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: Fundamental Concurrency Models

These are the big-picture paradigms every concurrent system is built on — the mental models you choose between before writing a line of code. They split roughly into how work communicates (actors and CSP pass messages; event loops and async share none) and how work is scheduled (OS threads, green threads, M:N hybrids), and the same language often offers several at once.

Model	Example	Description
Threads and processes	`Thread t = new Thread(() -> doWork());` `t.start();`	• OS-managed units of execution • threads share memory, processes are isolated • threads have lower overhead but require synchronization
Actor model	`case class Message(data: String)` `actor ! Message("hello")`	• Isolated actors communicate via asynchronous messages • each actor processes messages sequentially • popular in Erlang/Elixir/Akka • avoids shared state
CSP (Communicating Sequential Processes)	`ch := make(chan int)` `ch <- 42`	• Channels for message passing between goroutines • anonymous communication (vs. actor identities) • core abstraction in Go and Clojure core.async
Async/await and coroutines	`async def fetch():` `await asyncio.sleep(1)`	• Cooperative multitasking using async functions that yield at await points • single-threaded event loop schedules coroutines • ideal for I/O-bound workloads
Green threads / fibers	`Fiber.new { sleep 1 }.resume`	• User-space threads scheduled by runtime (not OS) • lower context-switch overhead • Ruby fibers and pre-1.2 Go goroutines are examples
M:N threading (hybrid)	N/A (runtime implementation)	• M user threads multiplexed onto N OS threads • Go's goroutine scheduler (M:N) • balances parallelism with low overhead
Event loop	`setTimeout(() => console.log('tick'), 0)`	• Single-threaded loop polling for events (I/O, timers) • JavaScript and Node.js core model • non-blocking I/O via callbacks/promises
Data parallelism	`arr.par_iter().map(\|x\| x * 2)`	• Same operation applied across data chunks in parallel • GPUs and SIMD • Rust Rayon and Python NumPy use this pattern
Task parallelism	`CompletableFuture.supplyAsync(() -> compute())`	• Different operations run concurrently • fork-join and thread pools • common in Java ExecutorService and C++ std::async

Table 2: Language-Specific Threading Models

The abstract models above land very differently once a real language gets hold of them, and this is where the trade-offs bite. Java's virtual threads and Go's goroutines both chase cheap massive concurrency, Python's GIL famously caps thread parallelism, and Rust pushes safety into the compiler with Send/Sync — knowing each runtime's quirks is what saves you from picking the wrong tool for the workload.

Language	Example	Description
Java virtual threads (Project Loom)	`Thread.startVirtualThread(() -> fetch());`	• Lightweight threads (M:N) managed by JVM • millions can run concurrently • blocks only logical thread, not OS thread • available since Java 21.

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

Table 3: Synchronization Primitives

When threads do share memory, these are the locks and gates that keep them from stepping on each other. They range from the basic exclusive mutex up through counting semaphores, reader-writer locks, and condition variables, then on to the coordination primitives — barriers, latches, and phasers — that make a group of threads rendezvous at the same point. Picking the lightest primitive that still guarantees correctness is the whole game.

Primitive	Example	Description
Mutex (mutual exclusion lock)	`let data = Mutex::new(vec![]);` `let guard = data.lock().unwrap();`	• Exclusive lock for protecting shared data • blocks threads until lock is available • supports reentrant and non-reentrant variants

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

Table 4: Atomic Operations and Memory Ordering

This is the low-level bedrock beneath every lock: indivisible hardware operations like compare-and-swap, and the memory-ordering rules that decide when one thread's writes become visible to another. The ordering spectrum runs from strict sequential consistency down to relaxed, trading guarantees for speed — and the happens-before relationship is the formal thread that ties it all together.

Concept	Example	Description
Compare-and-swap (CAS)	`atomic.compare_exchange_strong(expected, new_val)`	• Atomic read-modify-write that updates value only if it matches expected • foundation of lock-free algorithms • hardware instruction

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

Table 1: Fundamental Concurrency Models

Model	Example	Description
Threads and processes	`Thread t = new Thread(() -> doWork());` `t.start();`	• OS-managed units of execution • threads share memory, processes are isolated • threads have lower overhead but require synchronization
Actor model	`case class Message(data: String)` `actor ! Message("hello")`	• Isolated actors communicate via asynchronous messages • each actor processes messages sequentially • popular in Erlang/Elixir/Akka • avoids shared state
CSP (Communicating Sequential Processes)	`ch := make(chan int)` `ch <- 42`	• Channels for message passing between goroutines • anonymous communication (vs. actor identities) • core abstraction in Go and Clojure core.async
Async/await and coroutines	`async def fetch():` `await asyncio.sleep(1)`	• Cooperative multitasking using async functions that yield at await points • single-threaded event loop schedules coroutines • ideal for I/O-bound workloads
Green threads / fibers	`Fiber.new { sleep 1 }.resume`	• User-space threads scheduled by runtime (not OS) • lower context-switch overhead • Ruby fibers and pre-1.2 Go goroutines are examples
M:N threading (hybrid)	N/A (runtime implementation)	• M user threads multiplexed onto N OS threads • Go's goroutine scheduler (M:N) • balances parallelism with low overhead
Event loop	`setTimeout(() => console.log('tick'), 0)`	• Single-threaded loop polling for events (I/O, timers) • JavaScript and Node.js core model • non-blocking I/O via callbacks/promises
Data parallelism	`arr.par_iter().map(\|x\| x * 2)`	• Same operation applied across data chunks in parallel • GPUs and SIMD • Rust Rayon and Python NumPy use this pattern
Task parallelism	`CompletableFuture.supplyAsync(() -> compute())`	• Different operations run concurrently • fork-join and thread pools • common in Java ExecutorService and C++ std::async

Table 2: Language-Specific Threading Models

Language	Example	Description
Java virtual threads (Project Loom)	`Thread.startVirtualThread(() -> fetch());`	• Lightweight threads (M:N) managed by JVM • millions can run concurrently • blocks only logical thread, not OS thread • available since Java 21.

Table 3: Synchronization Primitives

Primitive	Example	Description
Mutex (mutual exclusion lock)	`let data = Mutex::new(vec![]);` `let guard = data.lock().unwrap();`	• Exclusive lock for protecting shared data • blocks threads until lock is available • supports reentrant and non-reentrant variants

Table 4: Atomic Operations and Memory Ordering

Concept	Example	Description
Compare-and-swap (CAS)	`atomic.compare_exchange_strong(expected, new_val)`	• Atomic read-modify-write that updates value only if it matches expected • foundation of lock-free algorithms • hardware instruction