Concurrency terms
Doing many things at once — safely, correctly, efficiently
Writing code that does multiple things at once — correctly — is one of the hardest problems in software engineering. This category covers threads, processes, async/await, event loops, locks, race conditions, deadlocks, and the concurrency models used in modern languages and runtimes. Getting concurrency wrong is subtle; these terms help you get it right.
More on Concurrency
History
Concurrency emerged as a critical concern in the 1960s with the advent of multiprogramming and multitasking operating systems, where a single processor needed to manage multiple tasks seemingly simultaneously. Early approaches relied on locks and semaphores, formalized by Dijkstra and others, to prevent race conditions and coordinate resource access. The rise of multicore processors in the 2000s transformed concurrency from an optional optimization into a necessity for performance, spurring language-level abstractions like goroutines (Go), async/await (JavaScript, Python, C#), and the actor model (Akka, Erlang). Modern practice has shifted from low-level thread management toward higher-level patterns—event loops, lock-free algorithms, and message passing—that reduce cognitive overhead and improve safety. Today, concurrency is foundational to systems design, from web servers and microservices to real-time applications, with ongoing research into better tooling for reasoning about correctness and preventing subtle bugs like data races and deadlocks.
Key concepts
- Concurrency vs Parallelism
- Processes vs Threads
- Race Condition
- Mutex & Locking
- Deadlock
- Atomic Operations
- Thread Safety
- Memory Barriers & Visibility
Best references
-
Java Concurrency in Practice Definitive guide by Goetz et al. on concurrent programming principles, thread safety, and practical patterns; concepts transfer directly to other languages and frameworks.
-
POSIX Threads Programming (Butenhof) Authoritative reference on POSIX thread semantics, mutexes, condition variables, and memory visibility—foundational for understanding OS-level concurrency abstractions.
-
The Go Memory Model Official specification defining memory visibility and synchronization guarantees in Go; illustrates modern concurrency semantics and goroutine interaction patterns.
-
Designing Data-Intensive Applications (Kleppmann) Comprehensive coverage of distributed concurrency concepts including consistency models, consensus algorithms, and real-world trade-offs in concurrent systems.
✦ Latest in Concurrency
Typed relationships here
Edges touching a Concurrency term.
- MySQL Connection Pooling Specializes Database Connection Pooling 4d
- Lock-Free Programming Leverages Compare-and-Swap (CAS) 6d
- Semaphore Often seen in Database Connection Pooling Jun 12
- Semaphore Enables Deadlock Jun 11
- Pessimistic Locking Leverages Mutex & Locking Jun 11
🤖 AI Guestbook — Concurrency educational data only
|
|
Last 30 days
Agents 1
Claude 1
PetalBot 8Perplexity 1Ahrefs 1Bing 1
Amazonbot 282Scrapy 251Perplexity 235Google 149Ahrefs 130ChatGPT 94Unknown AI 90SEMrush 79Meta AI 61Bing 36Claude 31PetalBot 25Majestic 15Sogou 7Qwen 3
Most referenced — Concurrency
How they use it
crawler 1.4k
crawler_json 89
pre-tracking 28
Category total1.5k pings
Terms pinged32 / 32
Distinct agents14
Structured Concurrency
PHP 8.1+
A model where child tasks live inside a parent scope that waits for all of them to finish before it exits, so no task is ever orphaned.
2w ago
Concurrency advanced
Mutex vs Semaphore
PHP 7.0+
1
A mutex allows only one thread to access a resource at a time — a semaphore controls access to a pool of N identical resources.
CWE-362
3mo ago
Concurrency advanced
Actor Model
The Actor Model treats everything as an actor — isolated units that communicate only by message passing, never sharing state — eliminating race conditions by design.
3mo ago
Concurrency advanced
Atomic Operations
2
An atomic operation completes entirely or not at all — no intermediate state is visible to other threads. Atomic ops are the building blocks of lock-free concurrency.
3mo ago
Concurrency intermediate
Atomic Operations
5
Atomic operations complete indivisibly — no other thread can observe an intermediate state. The foundation for lock-free concurrency and database counters.
3mo ago
Concurrency intermediate
Compare-And-Swap (CAS)
1
CAS atomically compares a memory location to an expected value and only swaps it if equal — the foundation of lock-free algorithms and optimistic concurrency control.
3mo ago
Concurrency advanced
Concurrency vs Parallelism
Concurrency is about dealing with multiple tasks at once (structuring); parallelism is actually executing multiple tasks simultaneously (hardware). You can have one without the other.
3mo ago
Concurrency beginner
Database Connection Pooling
2
Connection pooling reuses a fixed set of database connections across requests — eliminating the 50–200ms connection overhead on every request and limiting DB connection count.
3mo ago
Concurrency intermediate
Deadlock
3
A deadlock occurs when two or more processes each hold a resource the other needs — both wait forever. Prevention requires consistent lock ordering or timeouts.
3mo ago
Concurrency intermediate
Event-Driven Concurrency
1
Event-driven concurrency uses a single-threaded event loop to handle many concurrent I/O operations — no threads, no locks, but requires non-blocking code throughout.
3mo ago
Concurrency intermediate
Goroutine-Style Concurrency
Goroutines (Go) and similar lightweight green threads — coroutines, fibers — enable thousands of concurrent tasks with minimal memory, multiplexed onto OS threads by a runtime scheduler.
3mo ago
Concurrency intermediate
Lock-Free Programming
1
Lock-free algorithms guarantee system-wide progress without mutexes — using atomic CPU instructions (CAS) so at least one thread always makes forward progress even if others are delayed.
3mo ago
Concurrency advanced
Memory Barriers & Visibility
1
Memory barriers (fences) force the CPU and compiler to complete memory operations in order — ensuring changes made by one thread are visible to others at the right time.
3mo ago
Concurrency advanced
Mutex & Locking
3
A mutex (mutual exclusion lock) ensures only one thread/process can access a critical section at a time — the fundamental primitive for preventing race conditions.
3mo ago
Concurrency intermediate
Optimistic Locking
2
Optimistic locking detects conflicts at commit time using a version number — no locks held during the transaction, high throughput for low-contention scenarios.
3mo ago
Concurrency intermediate
Pessimistic Locking
5
Pessimistic locking acquires an exclusive lock immediately on read — preventing any concurrent modification. Right for high-contention scenarios but reduces throughput.
3mo ago
Concurrency intermediate
Producer-Consumer Pattern
Producer-Consumer decouples work generation from processing — producers add to a queue, consumers process independently, buffering load spikes and enabling parallel throughput.
3mo ago
Concurrency intermediate
Promises & Futures
PHP 7.0+
4
Abstractions representing the eventual result of an async operation — a Promise or Future is a placeholder for a value not yet available, enabling non-blocking code composition without nested callbacks.
3mo ago
Concurrency intermediate
Race Condition
4
A race condition occurs when the outcome of a program depends on the relative timing of concurrent operations — two threads reading and writing shared state without coordination.
3mo ago
Concurrency intermediate
Semaphore
5
A semaphore is a generalised mutex that allows N concurrent accesses — a counting semaphore with value N lets N threads proceed, blocking the (N+1)th.
3mo ago
Concurrency intermediate