CodeClarityLab / Glossary
Ctrl K
← Home ← Codex ← DEBT
Browse by Category
+ added · ✎ updated 7d
Pages
⚖Terms of Use ⓘAbout ✍Contribute 🧠Logic graph ✉Contact

Concurrency terms

18 terms of 1506 total

🔀 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 · 4 references · key concepts

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.
🧠 Logic graph · Concurrency
25 edges here
10 verbs used
20 terms touched
✦ Latest in Concurrency

Typed relationships here

Edges touching a Concurrency term.

Sort A → Z Recently Added Recently Updated Difficulty Most Viewed Most Rated Most Shared
DEBT Burden Trap Effort Detectability ↓ Desc ↑ Asc
Level All Beginner Intermediate Advanced
A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
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
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
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
Starvation & Livelock
Starvation: a thread never gets resources because others monopolise them. Livelock: threads actively respond to each other but make no progress — like two people stepping aside for each other indefinitely.
3mo ago Concurrency intermediate
Thread Safety PHP 7.0+
Thread-safe code produces correct results regardless of how multiple threads interleave — achieved through immutability, atomic operations, or synchronisation primitives.
3mo ago Concurrency intermediate
Thundering Herd Problem
Thundering herd: many processes simultaneously wake up to handle one event — all compete, one wins, the rest wasted work. Common after cache expiry or server restart.
3mo ago Concurrency intermediate
Diagram: Asynchronous vs Parallel Execution Asynchronous vs Parallel Execution PHP 7.0+
Async enables concurrency within a single thread by interleaving tasks during I/O waits; parallel execution uses multiple threads/processes for true simultaneous CPU execution.
3mo ago Concurrency intermediate
Diagram: Processes vs Threads Processes vs Threads PHP 7.0+
Processes are independent execution units with separate memory; threads share memory within a process — threads are lighter but require synchronisation to be safe.
3mo ago Concurrency intermediate
✓ schema.org compliant