Concurrency¶

Version: v3 · 2026-09-16 · History · 1 correction
Prime #: 157
Domain group: Applied Sciences & Engineering
Origin domain: Computer Science & Software Engineering
Also from: Operations Research, Biology & Ecology, Organizational & Management Science
Aliases: Parallelism, Simultaneous Processing
Related primes: Deadlock, Pipeline, Synchronization

Core Idea¶

Concurrency is the ability of a system to handle multiple independent or interdependent processes occurring simultaneously, often requiring coordination, synchronization, or conflict resolution.

How would you explain it like I'm…

Many things at once

In a busy kitchen, one cook stirs a pot, another chops carrots, and another washes plates, all at the same time. They have to share the sink and the stove without crashing into each other. Concurrency is just lots of things happening together and not bumping.

Many things happening together

Concurrency means a system has several things going on at the same time, and those things sometimes need to share or take turns. Think of a kitchen with three cooks all reaching for the same pan. They need rules about who goes first and how to wait so the meal still comes out right. Computers do this too: many programs share one processor and memory, and the system has to keep their actions in a sensible order.

Overlapping tasks needing coordination

Concurrency is the property of a system in which multiple independent or interdependent processes proceed in time-overlapping fashion. The processes might be threads in a program, customers at a bank, or signals in a brain. Because they overlap, you have to worry about ordering (which event happened first?), resource contention (who gets the shared printer?), and logical correctness when their steps interleave in unexpected ways. Concurrency is not the same as parallelism, which is about literally executing things simultaneously on different hardware. A system can be concurrent on a single processor by rapidly switching between tasks, and it still needs the same coordination tools.

Concurrency is the ability of a system to manage multiple independent or interdependent processes occurring simultaneously in time, raising structural questions about ordering, resource contention, and logical correctness under arbitrary interleaving. It is distinct from parallelism (true simultaneous physical execution): a single-core CPU can be highly concurrent by time-slicing, and a parallel system without coordination need not be concurrent in the design sense. The core challenge is that when separate loci of execution share state, the set of possible interleavings explodes combinatorially, so naive code that is correct in sequential isolation may exhibit race conditions, deadlocks, livelocks, or starvation when run concurrently. Coordination mechanisms — locks, semaphores, monitors, message passing, transactional memory, lock-free data structures — exist to constrain interleavings to those that preserve invariants. Reasoning frameworks include happens-before relations, linearizability, serializability, and various memory-consistency models that specify exactly what concurrent observers can see.

Tensions in Practice¶

Broad Use¶

Computing: Multi-threading in processors and distributed computing.
Biology: Parallel processing in neural networks (different brain regions working at the same time).
Economics: Simultaneous market transactions across global financial exchanges.
Project Management: Handling multiple tasks or workflows across different teams without conflicts.
Traffic Systems: Coordinating multiple traffic signals to prevent congestion.

Clarity¶

Highlights how systems manage multiple ongoing operations without breakdowns.

Manages Complexity¶

Encourages thinking about task division, prioritization, and dependencies.

Abstract Reasoning¶

Introduces principles like asynchronous execution, coordination costs, and distributed decision-making.

Knowledge Transfer¶

The idea of handling simultaneous workflows without deadlocks applies in software, logistics, neuroscience, and organizational planning.

Example¶

Airport control towers manage simultaneous flights landing and taking off, ensuring that independent operations don't lead to conflicts.

Relationships to Other Abstractions¶

Current abstraction Concurrency Prime

Foundational — no parent edges in the catalog.

Children (17) — abstractions linked here by typed relations

Background process Domain-specific is a kind of Concurrency

It remains its own entry because its identity is fixed by the operating system and version, executable and process owner, launch mechanism, session and terminal relation, lifecycle, privileges, triggers, resource limits, logs and foreground communication.
Communicating sequential processes Domain-specific is a kind of Concurrency

The candidate literally instantiates prime:concurrency.
Instruction-level parallelism Domain-specific is a kind of Concurrency

What makes it its own entry: the domain-specific identity determined by parallel execution preserves the single-thread architectural result and respects every true dependency, control commitment, exception, and resource constraint.
Live distributed object Domain-specific is a kind of Concurrency

What makes it its own entry: A running distributed protocol instance presented as one identity-bearing object with encapsulated state, participants and externally observable behavior.
Micro-thread (multi-core) Domain-specific is a kind of Concurrency

It remains its own entry because its identity is fixed by the thread granularity, per-core context storage, scheduling rule, dependency and communication model, and latency-hiding mechanism.

▸ Show 12 more

Operational transformation Domain-specific is a kind of Concurrency
It remains its own entry because its identity is fixed by the shared document model, primitive operations and positions, replica and causality metadata, concurrency relation, inclusion or exclusion transforms, execution protocol, convergence and causality properties, intention criterion and undo behavior.
Parallel algorithm Domain-specific is a kind of Concurrency
It remains its own entry because its identity is fixed by the problem and input size, parallel machine and memory model, task decomposition and dependency DAG, processor count, communication and synchronization, work and span, correctness and determinism and scalability.
Parallel RAM Domain-specific is a kind of Concurrency
It remains its own entry because its identity is fixed by the processor count as a function of input, synchronous step model, shared memory and word size, local processor state, read-write conflict class and resolution, algorithm, time and work bounds and ignored communication costs.
Shared memory Domain-specific is a kind of Concurrency
It remains its own entry because its identity is fixed by the processes, threads or devices, physical and virtual region, mapping and permissions, data layout, consistency and coherence model, atomic operations, synchronization, ownership, lifetime, cache effects, failure recovery, and security boundary.
Temporal Process Language Domain-specific is a kind of Concurrency
What makes it its own entry: A timed process calculus extending CCS with multiparty synchronization on an abstract global clock signal.
Calculus of Communicating Systems Domain-specific presupposes Concurrency
CCS formally **models Concurrency**, and its handshake rule instantiates **Synchronization**.
MapReduce Domain-specific presupposes Concurrency
MapReduce presupposes concurrent independent map and reduce tasks as the execution regime its programmer contract is designed to make safe.
Consistency Model Prime presupposes Concurrency
'Concurrency is the CONDITION — multiple operations in flight; a consistency model is the CONTRACT specifying which observations of that concurrency are legal.
Coordination Prime presupposes Concurrency
Coordination presupposes concurrency because aligning independent actors into coherent collective outcome only arises when multiple processes proceed simultaneously.
Eventual Consistency Prime presupposes Concurrency
Concurrency raises the reconciliation question; eventual_consistency is 'one discipline for living with the divergence concurrency creates' — accept uncoordinated concurrent writes, diverge, reconcile by merge.
Interference and Contention Prime presupposes Concurrency
Interference and contention presupposes concurrency because mutual interference among shared-resource consumers requires the consumers to proceed in overlapping time.
Race Condition Prime presupposes Concurrency
Race Condition presupposes Concurrency, whose structure must already obtain for the child mechanism to be meaningful or operational.

Not to Be Confused With¶

Concurrency is not Synchronization because Concurrency is the logical interleaving of multiple independent processes occurring in overlapping time, while Synchronization is the alignment of timing across oscillating processes to maintain phase coherence.
Concurrency is not Transaction because Concurrency describes multiple processes overlapping in time and requiring coordination, while a Transaction is a unit of work guaranteed atomic commit (all-or-nothing) regardless of whether it is concurrent with other operations.
Concurrency is not Sequencing because Concurrency allows multiple processes to proceed simultaneously respecting partial order constraints, while Sequencing determines a specific total order in which tasks execute and prerequisites complete.
Concurrency is not Coordination because Concurrency is the fact of multiple processes running simultaneously, while Coordination is the active apparatus (protocols, signals, rules) that aligns independent agents toward coherent outcomes despite concurrency.
Concurrency is not Deadlock because Concurrency is the property that multiple processes can execute in overlapping time, while Deadlock is a failure mode in concurrent systems where circular waiting prevents any process from proceeding.