Keywords

Every name a concept goes by — 169 titles and 361 aliases, one row each — pointing at the concept's page, which has the definition, the diagram of what it connects to, its name in each language and the lessons that measure it. The abbreviations page has the short forms; this page has the words.

Keyword	Concept	Category
ABA problem	ABA problem	Hazards
abandoned mutex	Lock poisoning	Synchronization
ACID	Consistency models	Distributed systems
Actor model	Actor model	Communication
actors	Actor model	Communication
AddressSanitizer	Memory error detector	Testing and tools
Amdahl's law	Speedup and Amdahl's law	Foundations
ASan	Memory error detector	Testing and tools
asymmetric coroutine	Coroutine	Units of execution
async	Asynchrony	Foundations
Async and await	Async and await	Async
async function	Async and await	Async
Async functions as state machines	Async functions as state machines	Async
async generator	Async stream	Async
Async runtime (executor and reactor)	Async runtime (executor and reactor)	Scheduling
Async stream	Async stream	Async
async-signal-safe	Reentrancy	Safety in languages
async/await	Async and await	Async
asynchronous channel	Buffered and bounded channels	Communication
asynchronous programming	Asynchrony	Foundations
Asynchrony	Asynchrony	Foundations
asyncio event loop	Async runtime (executor and reactor)	Scheduling
AsyncIterator	Async stream	Async
atomic consistency	Linearizability	Safety in languages
atomic integer	Atomic variable	Lock-free
Atomic variable	Atomic variable	Lock-free
atomics	Atomic variable	Lock-free
await	Join	Async
await point	Suspension point	Scheduling
background thread	Daemon and detached threads	Units of execution
Backpressure	Backpressure	Communication
Barrier	Barrier	Synchronization
BASE	Consistency models	Distributed systems
binary semaphore	Semaphore	Synchronization
Blocking and non-blocking calls	Blocking and non-blocking calls	Foundations
blocking I/O	Blocking and non-blocking calls	Foundations
blocking in async code	Blocking the event loop	Async
Blocking the event loop	Blocking the event loop	Async
bounded queue	Buffered and bounded channels	Communication
bounded-buffer problem	Producer-consumer	Communication
broadcast channel	Publish-subscribe and broadcast	Communication
Buffered and bounded channels	Buffered and bounded channels	Communication
buffered channel	Buffered and bounded channels	Communication
Busy waiting	Busy waiting	Scheduling
Cache coherence	Cache coherence	Parallelism
cache invalidation	Cache coherence	Parallelism
cache line contention	False sharing	Hazards
call_once	Run-once initialization	Synchronization
Callback	Callback	Async
callback hell	Callback	Async
Cancellation	Cancellation	Async
cancellation token	Cancellation	Async
CAS	Compare-and-swap	Lock-free
Celery	Task queue	Communication
Channel	Channel	Communication
check-then-act	Time of check to time of use	Hazards
checkpointing	Durable execution	Distributed systems
Child process	Child process	Units of execution
Classic synchronization problems	Classic synchronization problems	Synchronization
clock drift	Clock skew and drift	Distributed systems
Clock skew and drift	Clock skew and drift	Distributed systems
clock synchronization	Clock skew and drift	Distributed systems
coarse-grained	Granularity	Foundations
Communicating sequential processes	Communicating sequential processes	Communication
communication primitives	Concurrency primitives	Foundations
compare-and-set	Compare-and-swap	Lock-free
Compare-and-swap	Compare-and-swap	Lock-free
compare-exchange	Compare-and-swap	Lock-free
compiler reordering	Weak memory models and reordering	Hazards
completion handler	Callback	Async
Concurrency	Concurrency	Foundations
Concurrency models	Concurrency models	Foundations
Concurrency primitives	Concurrency primitives	Foundations
concurrent collections	Concurrent data structures	Lock-free
concurrent computing	Concurrency	Foundations
Concurrent data structures	Concurrent data structures	Lock-free
concurrent programming	Concurrency	Foundations
ConcurrentHashMap	Concurrent data structures	Lock-free
Condition variable	Condition variable	Synchronization
condvar	Condition variable	Synchronization
confinement	Thread confinement	Safety in languages
Consensus	Consensus	Distributed systems
Consistency models	Consistency models	Distributed systems
Contention	Contention	Hazards
contention profiling	Profiling concurrent programs	Testing and tools
context cancellation	Cancellation	Async
Context switch	Context switch	Units of execution
cooperative multitasking	Cooperative scheduling	Scheduling
Cooperative scheduling	Cooperative scheduling	Scheduling
coordination	Synchronization	Synchronization
copy-on-write	Read-copy-update	Lock-free
Coroutine	Coroutine	Units of execution
coroutines (C++20)	Async and await	Async
CountdownEvent	Latch	Synchronization
CountDownLatch	Latch	Synchronization
counting semaphore	Semaphore	Synchronization
CPU-bound	I/O-bound and CPU-bound work	Foundations
critical region	Critical section	Synchronization
Critical section	Critical section	Synchronization
CSP	Communicating sequential processes	Communication
CUDA	GPU computing	Parallelism
CyclicBarrier	Barrier	Synchronization
Daemon and detached threads	Daemon and detached threads	Units of execution
daemon thread	Daemon and detached threads	Units of execution
Dangling pointer	Dangling pointer	Hazards
data inconsistency	Safety failure	Hazards
Data parallelism	Data parallelism	Parallelism
Data race	Data race	Hazards
Data-race freedom by construction	Data-race freedom by construction	Safety in languages
Dataflow programming	Dataflow programming	Communication
deadline	Timeout	Async
deadline scheduling	Earliest deadline first	Real-time systems
Deadlock	Deadlock	Hazards
deadlock detection	Debugging concurrent programs	Testing and tools
deadly embrace	Deadlock	Hazards
Debugging concurrent programs	Debugging concurrent programs	Testing and tools
defer unlock	Scoped locking	Synchronization
deferred	Future and promise	Async
detach	Detached thread	Units of execution
detached thread	Daemon and detached threads	Units of execution
Detached thread	Detached thread	Units of execution
Deterministic scheduling for tests	Deterministic scheduling for tests	Testing and tools
deterministic simulation	Deterministic scheduling for tests	Testing and tools
dining philosophers	Classic synchronization problems	Synchronization
distributed async await	Durable execution	Distributed systems
Distributed computing	Distributed computing	Distributed systems
distributed platform	Distributed computing	Distributed systems
distributed systems	Distributed computing	Distributed systems
divide and conquer in parallel	Fork-join	Parallelism
double-checked locking	Run-once initialization	Synchronization
Durable execution	Durable execution	Distributed systems
Earliest deadline first	Earliest deadline first	Real-time systems
EDF	Earliest deadline first	Real-time systems
epoll	I/O multiplexing	Scheduling
Escape analysis	Escape analysis	Safety in languages
escapes to heap	Escape analysis	Safety in languages
event dispatch thread	UI thread	Units of execution
Event loop	Event loop	Scheduling
event-driven architecture	Event-driven programming	Async
Event-driven programming	Event-driven programming	Async
eventual consistency	Consistency models	Distributed systems
exclusive access	Mutual exclusion	Synchronization
executor	Async runtime (executor and reactor)	Scheduling
executor	Thread pool and executor	Units of execution
ExecutorService	Thread pool and executor	Units of execution
extent	Object lifetime	Safety in languages
external consistency	Consistency models	Distributed systems
fairness	Starvation	Hazards
False sharing	False sharing	Hazards
Fan-out, fan-in	Fan-out, fan-in	Communication
fast user-space mutex	Futex	Synchronization
Fiber	Fiber	Units of execution
fine-grained	Granularity	Foundations
fire and forget	Detached thread	Units of execution
flaky concurrency bug	Heisenbug	Hazards
flow control	Backpressure	Communication
flow graph	Dataflow programming	Communication
fork and exec	Child process	Units of execution
Fork-join	Fork-join	Parallelism
ForkJoinPool	Fork-join	Parallelism
free threading	Global interpreter lock	Parallelism
Function coloring	Function coloring	Async
Futex	Futex	Synchronization
future	Future and promise	Async
Future and promise	Future and promise	Async
gen_server	OTP behaviours	Communication
general race	Race condition	Hazards
generator	Coroutine	Units of execution
GenServer	OTP behaviours	Communication
GIL	Global interpreter lock	Parallelism
Global interpreter lock	Global interpreter lock	Parallelism
go -race	Race detector	Testing and tools
Go memory model	Happens-before	Lock-free
Goroutine	Goroutine	Units of execution
goroutine dump	Debugging concurrent programs	Testing and tools
goroutine leak	Leaked tasks	Hazards
GPGPU	GPU computing	Parallelism
GPU computing	GPU computing	Parallelism
Granularity	Granularity	Foundations
Green threads and M:N scheduling	Green threads and M:N scheduling	Units of execution
guarded block	Condition variable	Synchronization
GUI thread	UI thread	Units of execution
Gustafson's law	Speedup and Amdahl's law	Foundations
GVL	Global interpreter lock	Parallelism
Happens-before	Happens-before	Lock-free
hard real-time	Real-time system	Real-time systems
Hazard pointers	Hazard pointers	Lock-free
Heisenbug	Heisenbug	Hazards
Helgrind	Race detector	Testing and tools
Hyper-Threading	Simultaneous multithreading	Parallelism
I/O multiplexing	I/O multiplexing	Scheduling
I/O-bound	I/O-bound and CPU-bound work	Foundations
I/O-bound and CPU-bound work	I/O-bound and CPU-bound work	Foundations
Idempotency	Idempotency	Distributed systems
idempotent	Idempotency	Distributed systems
Immutability	Immutability	Safety in languages
immutable object	Immutability	Safety in languages
Inter-process communication	Inter-process communication	Communication
interference	Race condition	Hazards
Interior mutability	Interior mutability	Safety in languages
Interleaving	Interleaving	Foundations
Interlocked	Atomic variable	Lock-free
interval	Timers and tickers	Async
intrinsic lock	Monitor	Synchronization
IOCP	I/O multiplexing	Scheduling
IPC	Inter-process communication	Communication
Java Memory Model	Happens-before	Lock-free
jcstress	Stress testing	Testing and tools
job queue	Task queue	Communication
Join	Join	Async
join handle	Join	Async
JoinHandle	Join	Async
kqueue	I/O multiplexing	Scheduling
Lamport clock	Logical clocks	Distributed systems
Latch	Latch	Synchronization
lazy initialization	Run-once initialization	Synchronization
Leaked tasks	Leaked tasks	Hazards
let it crash	Supervision	Communication
lifetime	Object lifetime	Safety in languages
lightweight threads	Green threads and M:N scheduling	Units of execution
Lincheck	Model checking	Testing and tools
Linearizability	Linearizability	Safety in languages
Livelock	Livelock	Hazards
Liveness failure	Liveness failure	Hazards
liveness property	Safety and liveness	Hazards
lock	Mutex	Synchronization
lock contention	Contention	Hazards
lock guard	Scoped locking	Synchronization
lock hierarchy	Lock ordering	Synchronization
Lock ordering	Lock ordering	Synchronization
Lock poisoning	Lock poisoning	Synchronization
Lock-free	Lock-free	Lock-free
lock_guard	Scoped locking	Synchronization
lockless	Lock-free	Lock-free
Logical clocks	Logical clocks	Distributed systems
loom	Deterministic scheduling for tests	Testing and tools
lost update	Safety failure	Hazards
M:N threading	Green threads and M:N scheduling	Units of execution
mailbox	Actor model	Communication
main thread	UI thread	Units of execution
Map-reduce	Map-reduce	Parallelism
MapReduce	Map-reduce	Parallelism
Memcheck	Memory error detector	Testing and tools
Memory error detector	Memory error detector	Testing and tools
memory leak	Leaked tasks	Hazards
memory model	Happens-before	Lock-free
message broker	Publish-subscribe and broadcast	Communication
message loop	Event loop	Scheduling
Message passing	Message passing	Communication
Message Passing Interface	MPI	Parallelism
mission-critical system	Real-time system	Real-time systems
Model checking	Model checking	Testing and tools
Monitor	Monitor	Synchronization
moved to heap	Escape analysis	Safety in languages
MPI	MPI	Parallelism
mpsc	Channel	Communication
MT-safe	Thread safety	Safety in languages
Multi-version concurrency control	Multi-version concurrency control	Distributed systems
Multiprocessing	Multiprocessing	Parallelism
Multitasking	Multitasking	Foundations
multithreading	Thread	Units of execution
Mutex	Mutex	Synchronization
mutex profile	Profiling concurrent programs	Testing and tools
Mutual exclusion	Mutual exclusion	Synchronization
mutual exclusion lock	Mutex	Synchronization
MVCC	Multi-version concurrency control	Distributed systems
non-blocking algorithm	Lock-free	Lock-free
non-blocking I/O	Blocking and non-blocking calls	Foundations
non-deterministic behaviour	Nondeterminism	Foundations
non-preemptive scheduling	Cooperative scheduling	Scheduling
non-uniform memory access	NUMA	Parallelism
Nondeterminism	Nondeterminism	Foundations
NTP	Clock skew and drift	Distributed systems
NUMA	NUMA	Parallelism
nursery	Structured concurrency	Async
Object lifetime	Object lifetime	Safety in languages
observables	Reactive programming	Async
OMP	OpenMP	Parallelism
OnceLock	Run-once initialization	Synchronization
OpenMP	OpenMP	Parallelism
OS process	Process	Units of execution
OS thread	Thread	Units of execution
OTP	OTP behaviours	Communication
OTP behaviours	OTP behaviours	Communication
Oversubscription	Oversubscription	Foundations
ownership by one thread	Thread confinement	Safety in languages
Parallel algorithms	Parallel algorithms	Parallelism
parallel computing	Parallelism	Foundations
parallel execution	Parallelism	Foundations
Parallel iterators and streams	Parallel iterators and streams	Parallelism
Parallel prefix sum	Parallel prefix sum	Parallelism
parallel search	Parallel algorithms	Parallelism
parallel sort	Parallel algorithms	Parallelism
parallel streams	Parallel iterators and streams	Parallelism
Parallelism	Parallelism	Foundations
parallelism models	Concurrency models	Foundations
Partial failure	Partial failure	Distributed systems
Paxos	Consensus	Distributed systems
performance tuning	Profiling concurrent programs	Testing and tools
persistent data structure	Immutability	Safety in languages
Pin	Pinning	Async
Pinning	Pinning	Async
Pipeline	Pipeline	Communication
pipes	Inter-process communication	Communication
pipes and filters	Pipeline	Communication
platform thread	Thread	Units of execution
PLINQ	Parallel iterators and streams	Parallelism
poisoned mutex	Lock poisoning	Synchronization
poll	Polling	Scheduling
poll(2)	I/O multiplexing	Scheduling
Polling	Polling	Scheduling
preemption	Preemptive scheduling	Scheduling
preemptive multitasking	Preemptive scheduling	Scheduling
Preemptive scheduling	Preemptive scheduling	Scheduling
prefix scan	Parallel prefix sum	Parallelism
Priority inversion	Priority inversion	Hazards
Process	Process	Units of execution
process pool	Multiprocessing	Parallelism
process scheduler	Scheduler	Scheduling
ProcessPoolExecutor	Multiprocessing	Parallelism
Producer-consumer	Producer-consumer	Communication
producer-consumer problem	Producer-consumer	Communication
Profiling concurrent programs	Profiling concurrent programs	Testing and tools
Project Loom	Virtual thread	Units of execution
promise	Future and promise	Async
PTP	Clock skew and drift	Distributed systems
pub/sub	Publish-subscribe and broadcast	Communication
Publish-subscribe and broadcast	Publish-subscribe and broadcast	Communication
queue	Channel	Communication
race	Race condition	Hazards
race	Select	Communication
Race condition	Race condition	Hazards
Race detector	Race detector	Testing and tools
Raft	Consensus	Distributed systems
RAII guard	Scoped locking	Synchronization
Rate-monotonic scheduling	Rate-monotonic scheduling	Real-time systems
rayon	Parallel iterators and streams	Parallelism
RCU	Read-copy-update	Lock-free
Reactive Extensions	Reactive programming	Async
Reactive programming	Reactive programming	Async
ReactiveX	Reactive programming	Async
reactor	Async runtime (executor and reactor)	Scheduling
Read-copy-update	Read-copy-update	Lock-free
Read-write lock	Read-write lock	Synchronization
readers-writer lock	Read-write lock	Synchronization
readers-writers problem	Classic synchronization problems	Synchronization
Real-time system	Real-time system	Real-time systems
recursive lock	Reentrant lock	Synchronization
recursive mutex	Reentrant lock	Synchronization
Reentrancy	Reentrancy	Safety in languages
reentrant function	Reentrancy	Safety in languages
Reentrant lock	Reentrant lock	Synchronization
remote method invocation	Remote procedure call	Distributed systems
Remote procedure call	Remote procedure call	Distributed systems
rendezvous	Barrier	Synchronization
rendezvous channel	Unbuffered channel	Communication
resource race	Race condition	Hazards
resource starvation	Starvation	Hazards
resume semantics	Durable execution	Distributed systems
RLock	Reentrant lock	Synchronization
RMI	Remote procedure call	Distributed systems
RMS	Rate-monotonic scheduling	Real-time systems
RPC	Remote procedure call	Distributed systems
run loop	Event loop	Scheduling
Run-once initialization	Run-once initialization	Synchronization
RwLock	Read-write lock	Synchronization
RWMutex	Read-write lock	Synchronization
Rx	Reactive programming	Async
safe memory reclamation	Hazard pointers	Lock-free
Safety and liveness	Safety and liveness	Hazards
Safety failure	Safety failure	Hazards
safety property	Safety and liveness	Hazards
scan	Parallel prefix sum	Parallelism
Scheduler	Scheduler	Scheduling
scheduling algorithm	Scheduling policy	Scheduling
Scheduling policy	Scheduling policy	Scheduling
Scoped locking	Scoped locking	Synchronization
Scoped thread	Scoped thread	Units of execution
Select	Select	Communication
select!	Select	Communication
select(2)	I/O multiplexing	Scheduling
Semaphore	Semaphore	Synchronization
Send and Sync	Send and Sync	Safety in languages
Sendable	Send and Sync	Safety in languages
SeqCst	Sequential consistency	Safety in languages
Sequential consistency	Sequential consistency	Safety in languages
Sequential execution	Sequential execution	Foundations
sequential programming	Sequential execution	Foundations
serial execution	Sequential execution	Foundations
setTimeout	Timers and tickers	Async
shared lock	Read-write lock	Synchronization
Shared memory	Shared memory	Communication
shared-exclusive lock	Read-write lock	Synchronization
shared_mutex	Read-write lock	Synchronization
SIGINT	Signals	Communication
signal handler	Signals	Communication
signals	Inter-process communication	Communication
Signals	Signals	Communication
SIGPIPE	Signals	Communication
SIMD	SIMD	Parallelism
Simultaneous multithreading	Simultaneous multithreading	Parallelism
single instruction, multiple data	SIMD	Parallelism
Sink	Async stream	Async
sleeping barber problem	Classic synchronization problems	Synchronization
SMT	Simultaneous multithreading	Parallelism
snapshot isolation	Multi-version concurrency control	Distributed systems
soft real-time	Real-time system	Real-time systems
software transactional memory	Transactional memory	Lock-free
spawn	Child process	Units of execution
spawned future	Task (async)	Units of execution
speedup	Speedup and Amdahl's law	Foundations
Speedup and Amdahl's law	Speedup and Amdahl's law	Foundations
SPIN	Model checking	Testing and tools
spin lock	Spinlock	Synchronization
spin loop	Busy waiting	Scheduling
spin-wait	Spinlock	Synchronization
spin-waiting	Busy waiting	Scheduling
Spinlock	Spinlock	Synchronization
spinning	Busy waiting	Scheduling
spurious wakeup	Condition variable	Synchronization
stack dump	Debugging concurrent programs	Testing and tools
stackful coroutine	Fiber	Units of execution
stackless coroutine	Coroutine	Units of execution
Starvation	Starvation	Hazards
std::latch	Latch	Synchronization
std::sync::Barrier	Barrier	Synchronization
STM	Transactional memory	Lock-free
stop token	Cancellation	Async
storage duration	Object lifetime	Safety in languages
store buffering	Weak memory models and reordering	Hazards
Stream	Async stream	Async
Stress testing	Stress testing	Testing and tools
strong consistency	Linearizability	Safety in languages
Structured concurrency	Structured concurrency	Async
structured thread	Scoped thread	Units of execution
subprocess	Child process	Units of execution
Supervision	Supervision	Communication
supervision tree	Supervision	Communication
Suspension point	Suspension point	Scheduling
symmetric coroutine	Coroutine	Units of execution
sync and async functions	Function coloring	Async
sync.Once	Run-once initialization	Synchronization
Synchronization	Synchronization	Synchronization
synchronization mechanisms	Synchronization	Synchronization
synchronization primitives	Concurrency primitives	Foundations
synchronization primitives	Synchronization	Synchronization
synchronized	Monitor	Synchronization
synchronized before	Happens-before	Lock-free
synchronized channel	Unbuffered channel	Communication
synchronous and asynchronous calls	Blocking and non-blocking calls	Foundations
synchronous channel	Unbuffered channel	Communication
synctest	Deterministic scheduling for tests	Testing and tools
task	Task (async)	Units of execution
Task	Future and promise	Async
Task (async)	Task (async)	Units of execution
task granularity	Granularity	Foundations
task group	Structured concurrency	Async
Task parallelism	Task parallelism	Parallelism
Task queue	Task queue	Communication
task switch	Context switch	Units of execution
the concurrency landscape	Concurrency models	Foundations
Thread	Thread	Units of execution
Thread confinement	Thread confinement	Safety in languages
thread dump	Debugging concurrent programs	Testing and tools
thread leak	Leaked tasks	Hazards
thread of execution	Thread	Units of execution
thread pool	Worker pool	Communication
Thread pool and executor	Thread pool and executor	Units of execution
Thread safety	Thread safety	Safety in languages
thread scheduler	Scheduler	Scheduling
thread starvation	Starvation	Hazards
thread-local storage	Thread confinement	Safety in languages
Thread-local storage	Thread-local storage	Units of execution
thread-local variable	Thread-local storage	Units of execution
thread-safe	Thread safety	Safety in languages
thread-safe containers	Concurrent data structures	Lock-free
thread-specific data	Thread-local storage	Units of execution
thread::scope	Scoped thread	Units of execution
ThreadPoolExecutor	Thread pool and executor	Units of execution
ThreadSanitizer	Race detector	Testing and tools
ticker	Timers and tickers	Async
Time of check to time of use	Time of check to time of use	Hazards
Timeout	Timeout	Async
Timers and tickers	Timers and tickers	Async
timestamp ordering	Logical clocks	Distributed systems
TLA+	Model checking	Testing and tools
TLS	Thread-local storage	Units of execution
TOCTOU	Time of check to time of use	Hazards
TOCTTOU	Time of check to time of use	Hazards
tokio	Async runtime (executor and reactor)	Scheduling
torn read	Safety failure	Hazards
TPL Dataflow	Dataflow programming	Communication
Transactional memory	Transactional memory	Lock-free
TrueTime	Clock skew and drift	Distributed systems
TSan	Race detector	Testing and tools
UB	Undefined behaviour	Hazards
UI thread	UI thread	Units of execution
unbounded channel	Buffered and bounded channels	Communication
Unbuffered channel	Unbuffered channel	Communication
undefined behavior	Undefined behaviour	Hazards
Undefined behaviour	Undefined behaviour	Hazards
Unix signals	Signals	Communication
Unpin	Pinning	Async
unsynchronized access	Data race	Hazards
use after free	Dangling pointer	Hazards
use after return	Dangling pointer	Hazards
use after scope	Dangling pointer	Hazards
user-space threads	Green threads and M:N scheduling	Units of execution
Valgrind	Memory error detector	Testing and tools
vector clock	Logical clocks	Distributed systems
vectorization	SIMD	Parallelism
Virtual thread	Virtual thread	Units of execution
virtual time	Deterministic scheduling for tests	Testing and tools
wait and notify	Condition variable	Synchronization
Wait-free	Wait-free	Lock-free
WaitGroup	Join	Async
WaitOnAddress	Futex	Synchronization
WCET	Worst-case execution time	Real-time systems
Weak memory models and reordering	Weak memory models and reordering	Hazards
weak ordering	Weak memory models and reordering	Hazards
what color is your function	Function coloring	Async
work queue	Task queue	Communication
Work stealing	Work stealing	Scheduling
work-stealing scheduler	Work stealing	Scheduling
Worker pool	Worker pool	Communication
workflow engine	Durable execution	Distributed systems
Worst-case execution time	Worst-case execution time	Real-time systems
write-back	Cache coherence	Parallelism
yield point	Suspension point	Scheduling
zombie thread	Leaked tasks	Hazards