Concurrency, Transactions & Process Coordination

← Back to Domain-Specific Families

Abstractions about coordinating concurrent and distributed computations through ordering, synchronization, transactions, locks, events, threads, and reliable communication. They include classic deadlock and scheduling problems, happened-before relations, commit protocols, marshalling, broadcast termination, and nondeterminism.

20 abstractions in this family — domain-specific abstractions that sit near one another in structural-signature space (k-means over structural-signature embeddings). Each is shown with its short description.

• Communicating sequential processes — A process algebra for specifying and reasoning about concurrent systems as sequential processes that synchronize through named communication events or channels.
• Database transaction — A bounded database unit of work whose reads and writes commit together or abort together under declared atomicity, consistency, isolation, and durability guarantees.
• Dining philosophers problem — A concurrency problem modeling processes that alternately need pairs of shared resources, exposing deadlock, starvation and fairness constraints.
• Event structure — A concurrency model representing events with causal enabling, conflict, and consistency relations that determine possible executions.
• Fork bomb — A denial-of-service failure pattern in which a process recursively creates new processes until process-table, memory or scheduling resources are exhausted.
• Happened-before — The least strict partial order on distributed events generated by local program order, message send-before-receive, and transitivity, capturing potential causality without assuming synchronized physical clocks.
• Join-pattern — A concurrency construct that atomically fires a reaction when a declared combination of asynchronous messages is simultaneously available on several channels.
• Live distributed object — A running distributed protocol instance presented as one identity-bearing object with encapsulated state, participants and externally observable behavior.
• Locks with ordered sharing — A family of transaction-concurrency protocols that soften lock conflicts by admitting ordered sharing while preserving a serialization order.
• Makespan — The elapsed time from the start of the earliest scheduled operation to completion of the latest operation or job.
• Marshalling (computer science) — The transformation of an in-memory object or call's structured state into a representation suitable for storage, transmission or crossing a runtime boundary, often with metadata needed for reconstruction.
• Polling system — A queueing system in which one server visits multiple queues according to a routing rule and applies a declared service discipline at each visit.
• Reentrant mutex — A mutual-exclusion lock that its owning thread may acquire repeatedly, tracking recursion depth and releasing ownership only after a matching number of unlocks.
• Sleeping barber problem — A classic synchronization problem modeling one service worker, a bounded waiting room and arriving clients to illustrate mutual exclusion, blocking and coordination without lost wakeups.
• Temporal Process Language — A timed process calculus extending CCS with multiparty synchronization on an abstract global clock signal.
• Terminating Reliable Broadcast — A fault-tolerant distributed-broadcast specification requiring all correct processes eventually to decide the same delivered value or a distinguished sender-failure value despite crash failures.
• Thread pool — A concurrency pattern that reuses a bounded set of worker threads to execute tasks drawn from a queue instead of creating a new thread for every task.
• Thread-local storage — A storage mechanism giving each execution thread its own instance of a variable that otherwise has static or global lifetime and access syntax.
• Two-phase commit protocol — A distributed atomic-commit protocol in which a coordinator first collects durable prepare votes and then tells every participant to commit or abort the transaction.
• Unbounded nondeterminism — A concurrency-model behavior in which a computation may make an unboundedly delayed or infinitely branching choice while fairness can still require eventual progress.