Concurrency Glossary

Browse 130 concurrency terms defined in plain English, from the cultural dictionary of computing.

130 Concurrency Terms

Actor
Actor is a concurrency model where the fundamental unit of computation is an independent entity called an actor that communicates with other actors exclusively...
Async
Short for asynchronous — a programming model where operations (typically I/O) are initiated and control returns immediately, allowing other work to proceed...
Async/Await
Async/Await is a programming syntax pattern that allows developers to write asynchronous code in a sequential, synchronous-looking style, making it...
Async Context
The logical execution context that travels across asynchronous boundaries so code can still access request IDs, tracing data, auth state, or other scoped...
Async Function
A function that can suspend while waiting for asynchronous operations and resume later, usually returning a promise, future, or similar awaitable result. Async...
asyncio
Python's standard library module for writing single-threaded concurrent code using coroutines, event loops, and non-blocking I/O — the foundation of modern...
Async Lock
A synchronization primitive used in asynchronous code to ensure only one task or a limited set of tasks can enter a critical section at a time without blocking...
Async Pattern
A recurring way of structuring asynchronous work, such as fan-out/fan-in, pipelines, task queues, backpressure, or cancellation-aware execution. Choosing the...
Async Pool
A mechanism for limiting and coordinating how many asynchronous tasks may run concurrently, often to avoid overwhelming external services or local resources....
Async Task
A unit of work scheduled to run asynchronously rather than immediately inline with the caller. Async tasks are common in job systems, event loops, UI...
Atomic Counter
A counter variable that can be incremented, decremented, or read safely across threads without race conditions by using atomic operations. Atomic counters are...
Atomic Reference
A reference holder that supports thread-safe atomic reads and swaps so shared pointers or objects can be updated without races. Atomic references are often...
Barrier
A synchronization point where multiple threads or tasks must all arrive before any of them can continue past that stage. Barriers are used in parallel...
BEAM
The virtual machine at the heart of the Erlang/OTP ecosystem (also running Elixir and other languages), designed for massively concurrent, fault-tolerant,...
Blocking Call
A function call that stops the current thread or execution path from doing anything else until the operation completes. Blocking calls are simple to reason...
Blocking Queue
A thread-safe queue whose producers or consumers wait when the queue is full or empty, making it useful for coordinating work between concurrent workers....
Bounded Channel
A channel with a fixed capacity limit, so sending eventually blocks or fails once the buffer is full until receivers catch up. Bounded channels are useful...
Busy Wait
A wait implemented by repeatedly checking a condition instead of sleeping or yielding efficiently, often used casually to describe wasteful polling. In...
Channel
A typed conduit through which goroutines or concurrent processes can send and receive values, providing synchronized communication without explicit locks....
Communication Channel
A path or abstraction through which data, signals, or messages move between parts of a program or between systems. In software design, communication channels...
Compare-and-Swap
An atomic CPU instruction that compares a memory location to an expected value and, only if they match, replaces it with a new value -- all in one...
Concurrency Bug
A defect caused by incorrect coordination between concurrent operations, such as race conditions, deadlocks, lost updates, or visibility issues. Concurrency...
Concurrency Control
A Concurrency Control is a development concept used to shape how software is built, executed, or maintained in real systems. Developers rely on it to make code...
Concurrency Limit
A configured cap on how many tasks, requests, workers, or operations may run in parallel at once. Concurrency limits are used to protect downstream...
Concurrency Model
A Concurrency Model is a development concept used to shape how software is built, executed, or maintained in real systems. Developers rely on it to make code...
Concurrency Pattern
A Concurrency Pattern is a development concept used to shape how software is built, executed, or maintained in real systems. Developers rely on it to make code...
Concurrency Primitive
A low-level synchronization building block such as a mutex, semaphore, atomic value, barrier, or condition variable used to coordinate concurrent execution....
Concurrent Access
The situation in which multiple threads, tasks, users, or systems access the same resource at the same time. Concurrent access must be managed carefully when...
Concurrent Collection
A Concurrent Collection is a development concept used to shape how software is built, executed, or maintained in real systems. Developers rely on it to make...
Concurrent Map
A map or dictionary implementation designed for safe access and updates by multiple threads or tasks at the same time. Concurrent maps typically use locks,...
Concurrent Programming
A Concurrent Programming is a development concept used to shape how software is built, executed, or maintained in real systems. Developers rely on it to make...
Concurrent Queue
A queue implementation built for safe producer and consumer access from multiple threads or tasks simultaneously. Concurrent queues are used in worker pools,...
Concurrent Read
A read operation occurring at the same time as other reads or writes on the same resource. Concurrent reads are often safe on immutable or properly...
Concurrent Set
A set data structure designed to support safe inserts, removals, and membership checks from multiple concurrent contexts. Concurrent sets are useful for...
Concurrent Write
A write that occurs at the same time as another write or read on the same mutable resource. Concurrent writes require coordination or merge logic because...
Context Switch
The process of saving one thread/process's state (registers, program counter, stack pointer) and loading another's so the CPU can switch between tasks. Costs...
Coroutine
A generalization of subroutines that can suspend execution at certain points and resume later, enabling cooperative multitasking without threads. Used...
Counting Semaphore
A Counting Semaphore is a development concept used to shape how software is built, executed, or maintained in real systems. Developers rely on it to make code...
Deadlock
A state where two or more processes are each waiting for the other to release a resource, so none of them can proceed. The computational equivalent of two...
Deadlock Detection
A Deadlock Detection is a development concept used to shape how software is built, executed, or maintained in real systems. Developers rely on it to make code...
Double-Checked Locking
A Double-Checked Locking is a development concept used to shape how software is built, executed, or maintained in real systems. Developers rely on it to make...
Elixir
A functional, concurrent programming language built on the Erlang VM (BEAM) designed for building scalable, fault-tolerant applications. Elixir combines...
Erlang
A functional programming language designed for building massively concurrent, fault-tolerant telecom systems. Erlang's 'let it crash' philosophy and...
Event Loop
Event Loop is a programming construct that continuously monitors for and dispatches events or messages in a program, enabling asynchronous, non-blocking I/O...
Fiber
A lightweight unit of execution that is cooperatively scheduled — the fiber explicitly yields control rather than being preemptively interrupted by the OS....
Finally Block
A Finally Block is a development concept used to shape how software is built, executed, or maintained in real systems. Developers rely on it to make code...
Future
A placeholder for a value that will be available at some point in the future, representing the result of an asynchronous computation. Called Future in...
GenServer
A generic server behavior module in Erlang/OTP and Elixir that abstracts the common client-server interaction pattern, handling synchronous and asynchronous...
Go
Go, also known as Golang, is a statically typed, compiled programming language designed at Google by Robert Griesemer, Rob Pike, and Ken Thompson. Released in...
Goroutine
A lightweight, user-space thread managed by the Go runtime rather than the OS, enabling massive concurrency with minimal overhead. Goroutines start with only a...
Greenthread
A lightweight thread managed by the runtime or a library rather than the operating system, enabling high concurrency with low overhead. Green threads in Go are...
Immutability
The property of data that cannot be changed after creation. Instead of modifying existing values, operations produce new values. Eliminates entire classes of...
Interlocked
An Interlocked is a development concept used to shape how software is built, executed, or maintained in real systems. Developers rely on it to make code easier...
IPC
Short for inter-process communication: the mechanisms operating systems provide for separate processes to exchange data or coordinate work. Common IPC methods...
Isolate
In Dart and Flutter, an independent worker with its own memory heap that runs concurrently without sharing state with other isolates, communicating only...
Latch
A synchronization primitive that allows one or more threads to wait until a set of operations in other threads completes. Unlike a mutex, a latch is typically...
Lightweight Thread
A thread of execution managed by the language runtime rather than the operating system kernel, using far less memory (often just a few KB of stack) and...
Lock
A synchronization primitive that enforces mutual exclusion — only one thread can hold the lock at a time, and all other threads that attempt to acquire it will...
Lock Contention
A performance bottleneck that occurs when multiple threads frequently compete for the same lock, causing them to block and wait instead of doing useful work....
Lock-Free Data Structure
A concurrent data structure that guarantees system-wide progress without using locks -- at least one thread makes progress in a finite number of steps...
Mailbox
A message queue associated with an actor or process in concurrent systems (notably Erlang/Elixir and Akka), where incoming messages are buffered until the...
Main Thread
The initial thread of execution created when a process starts, which typically owns the event loop, handles UI rendering, and is the only thread allowed to...
Memory Barrier
A CPU instruction that enforces ordering constraints on memory operations. Modern CPUs reorder reads and writes for performance, which can cause bugs in...
Memory Fence
A CPU instruction (also called a memory barrier) that enforces ordering constraints on memory operations, preventing the processor or compiler from reordering...
Memory Model
A formal specification defining how reads and writes to shared memory behave in a concurrent program — which reorderings the compiler and hardware are allowed...
Memory Order
A parameter on atomic operations (in C++, Rust, etc.) that specifies the strength of ordering guarantees: `relaxed` (no ordering), `acquire` (subsequent reads...
Message Passing
A communication paradigm where processes or objects exchange data by sending and receiving messages rather than sharing memory, reducing race conditions and...
Monitor
A synchronization construct that bundles a mutex with one or more condition variables, allowing threads to both mutually exclude each other from a critical...
Multi-Threading
A concurrency model in which a single process spawns multiple threads of execution that share the same memory space, enabling parallel work on multi-core CPUs...
Mutex
Mutual Exclusion — a synchronization primitive that ensures only one thread can access a shared resource at a time, preventing race conditions. The...
MVCC
Multi-Version Concurrency Control — a technique where the database maintains multiple versions of each row so that readers see a consistent snapshot without...
Non-Blocking
Describes an operation or API call that returns immediately rather than waiting for completion, allowing the calling thread to continue executing other work....
Non-Blocking IO
An I/O model in which system calls like `read()` and `write()` return immediately — either with available data or an EAGAIN/EWOULDBLOCK status — instead of...
Notify
A synchronization primitive operation that signals one or more waiting threads or coroutines that a condition they are interested in has changed, typically...
OS Thread
A kernel-managed thread of execution that shares its process's address space but has its own stack, register state, and scheduling priority. OS threads are...
Parallelism
The simultaneous execution of multiple computations, typically on separate CPU cores or machines. Unlike concurrency (which is about structure), parallelism is...
Parallel Processing
The simultaneous execution of multiple computations across separate CPU cores or processors to reduce wall-clock time. Unlike concurrency (which interleaves...
Pool
A cache of pre-initialized, reusable resources — such as database connections, threads, or objects — that can be checked out when needed and returned after...
Preemptive Scheduling
A CPU scheduling strategy in which the operating system can forcibly interrupt a running process or thread — typically via a timer interrupt — to allocate the...
Process
Process is an instance of a program in execution, representing one of the fundamental concepts in operating systems. When you launch an application, the OS...
Process Pool
A pre-forked collection of worker processes managed by a parent that dispatches tasks to idle workers and collects results, amortizing the overhead of process...
Promise
Promise is an object in asynchronous programming that represents the eventual completion (or failure) of an asynchronous operation and its resulting value. A...
Promise.all
A JavaScript method that takes an iterable of Promises and returns a single Promise that resolves with an array of all results when every input Promise...
Race Condition
A bug that occurs when the behavior of a system depends on the sequence or timing of uncontrollable events — when two operations 'race' and the outcome depends...
Race Detector
A dynamic analysis tool that instruments memory accesses at runtime to detect data races — unsynchronized concurrent reads and writes to the same variable....
Read-Copy-Update
A synchronization mechanism used heavily in the Linux kernel that allows readers to access shared data structures without acquiring any locks, while writers...
Read Lock
A shared lock that allows multiple threads to read a resource concurrently but blocks any thread attempting to acquire a write lock on the same resource. Read...
Read-Write Lock
A lock that distinguishes between shared (read) and exclusive (write) access: multiple readers can hold the lock concurrently, but a writer requires exclusive...
ReadWriteLock
A Java interface (java.util.concurrent.locks.ReadWriteLock) that provides a pair of associated locks — one for read-only operations and one for writing —...
Reference Capability
In the Pony programming language, a type system feature that annotates references with capabilities (iso, val, ref, box, trn, tag) controlling what an alias...
Rendezvous
A synchronization point where two or more processes, threads, or network peers meet to exchange data or coordinate before proceeding independently.
Resource Pool
A cache of pre-initialized, reusable resources — typically database connections, threads, or network sockets — that are borrowed by consumers and returned...
Runnable
A functional interface in Java (java.lang.Runnable) with a single void run() method, representing a unit of work that can be executed by a thread or executor....
Scatter-Gather
A concurrent pattern in which a request is fanned out (scattered) to multiple workers or services in parallel, and the results are collected (gathered) back...
Scheduler
A system component that decides which process, thread, or task gets access to a shared resource (typically a CPU core) and for how long, using policies like...
semaphore
A synchronization primitive that controls access to a shared resource through a counter, allowing a specified number of threads to access the resource...
Send
In Rust, a marker trait indicating that a type can be safely transferred across thread boundaries; if a type is `Send`, ownership can move to another thread...
Sequential Execution
A mode of execution in which instructions or tasks run one after another in a defined order, where each step must complete before the next begins — the default...
Serial Queue
A dispatch queue that executes tasks one at a time in FIFO order, ensuring mutual exclusion without explicit locks — central to Apple's Grand Central Dispatch...
Shared Memory
A region of memory that is mapped into the address space of multiple processes simultaneously, enabling the fastest form of inter-process communication since...
Shared State
Mutable data that is accessible by multiple threads, goroutines, or processes simultaneously, making it the primary source of race conditions, deadlocks, and...
Signal
An asynchronous notification sent to a process by the OS (e.g., SIGTERM, SIGKILL) to indicate an event, or in reactive programming, a primitive that holds a...
Snapshot Isolation
A database isolation model that gives each transaction a consistent snapshot while reducing read-write blocking. It shows up in application security, identity,...
Spawning
The act of creating a new process, thread, or concurrent task from a parent context. On Unix, process spawning typically involves fork+exec (or posix_spawn);...
Spin Lock
A low-level mutual exclusion primitive where a thread repeatedly checks (spins on) an atomic flag in a tight loop rather than yielding the CPU to the...
Sync
Short for synchronous — describes an operation that blocks the calling thread until it completes and returns a result, as opposed to async operations that...
Synchronization
The coordination of concurrent threads, processes, or distributed nodes to ensure correct ordering of operations and safe access to shared resources —...
Synchronization Primitive
A low-level building block — such as a mutex, semaphore, spinlock, condition variable, or atomic operation — provided by the OS or language runtime to...
Synchronized
In Java, a keyword that acquires an intrinsic monitor lock on an object (or class) before executing a block or method, ensuring that only one thread at a time...
Task
A unit of work that can be scheduled and executed, often asynchronously. In modern runtimes, tasks are lighter than threads and managed by an executor or event...
Task Parallelism
A form of parallelism where different tasks or functions are distributed across multiple processors, as opposed to data parallelism where the same operation is...
Thread
The smallest unit of execution that an operating system can schedule. Threads within a process share memory space, enabling parallel execution but requiring...
Thread Bomb
A bug or design that creates too many threads, overwhelming the system or making behavior chaotic. In engineering slang, thread bombs are concurrency problems...
Threading Model
The design that defines how a runtime or application maps work to OS threads — such as one-thread-per-request, event loop with a single thread (Node.js), green...
Thread Local
A variable storage mechanism where each thread gets its own independent copy of the data, avoiding synchronization overhead — commonly used to store...
Thread Pool
A collection of pre-created worker threads that process tasks from a shared queue. Eliminates the overhead of creating/destroying threads per request (which...
Thread Safety
The property of code that guarantees correct behavior when accessed by multiple threads simultaneously, achieved through techniques like locks, atomic...
Thread Starvation
A condition where all threads in a pool are occupied by long-running or blocked tasks, leaving no threads available to process incoming work — causing requests...
Time Slice
The short, fixed duration of CPU time (typically 1–10 milliseconds) that an OS scheduler allocates to a process or thread before preempting it and switching to...
Transactional Memory
A concurrency control mechanism that allows a block of memory read/write operations to execute atomically and in isolation — like a database transaction but...
Volatile
A type qualifier (in C, C++, Java, and others) that tells the compiler a variable's value may change at any time without any action being taken by the...
Wait Group
A synchronization primitive, most associated with Go's sync.WaitGroup, that maintains an internal counter which goroutines increment before starting work and...
web worker
A mechanism for running JavaScript in a background thread separate from the main page thread, preventing CPU-intensive tasks from blocking the user interface....
Web Worker
Web Worker is a JavaScript API that enables running scripts in background threads separate from the main execution thread of a web page, allowing...
Worker
A background execution context — in browsers, a Web Worker runs JavaScript on a separate thread from the main UI thread, communicating via postMessage; in...
Worker Pool
A collection of pre-spawned threads or processes that wait for tasks on a shared queue, amortizing the cost of thread/process creation across many jobs and...
Worker Thread
In Node.js, a worker_threads module API that spawns additional V8 isolates running in separate OS threads, sharing memory via SharedArrayBuffer and...
Work Stealing
A scheduling strategy where idle threads 'steal' tasks from busy threads' queues, achieving automatic load balancing without central coordination. Each thread...
Write Lock
An exclusive lock acquired on a resource — such as a database row, file, or memory region — that prevents any other thread or process from reading or writing...
Yield
A keyword or operation that pauses a function's execution and emits a value to the caller, preserving the function's local state so it can resume where it left...

Related Topics