All Concurrency Primitives

Use this as a quick map. For grouped discussion, see C++ concurrency library.

Thread objects and cooperative stop

• std::thread
• std::jthread
• std::this_thread
• std::stop_source
• std::stop_token
• std::stop_callback

Mutexes and locks

• std::mutex
• std::recursive_mutex
• std::timed_mutex
• std::recursive_timed_mutex
• std::shared_mutex
• std::shared_timed_mutex
• std::lock_guard
• std::scoped_lock
• std::unique_lock
• std::shared_lock
• std::lock
• std::try_lock

Condition variables and waiting

• std::condition_variable
• std::condition_variable_any
• std::notify_all_at_thread_exit

Coordination primitives

• std::latch
• std::barrier
• std::counting_semaphore
• std::binary_semaphore

Futures and asynchronous task state

• std::future<T>
• std::shared_future<T>
• std::promise<T>
• std::packaged_task
• std::async
• std::launch
• std::future_status

Atomics and memory ordering

• std::atomic<T>
• std::atomic_flag
• std::atomic_ref<T>
• std::memory_order
• memory_order_relaxed
• memory_order_consume
• memory_order_acquire
• memory_order_release
• memory_order_acq_rel
• memory_order_seq_cst

High-level guidance

• Prefer std::jthread for local thread ownership.
• Guard invariants with mutexes first; only move to atomics when measurement justifies it.
• Wait on predicates, not on timing guesses.
• Treat memory-order tuning as advanced work that needs careful review.

Small worked example

#include <semaphore>
#include <thread>

int main() {
	std::binary_semaphore ready{0};

	std::jthread worker([&] {
		prepare_data();
		ready.release();
	});

	ready.acquire();
	consume_data();
}

This is the common shape of a coordination primitive: not protecting shared invariants, but signaling that one phase of work is allowed to continue.

Selection guide

• use std::jthread for owned worker threads with cooperative stop support
• use mutexes plus condition variables when shared state and predicate-based waiting go together
• use semaphores when the question is permits, slots, or one-shot readiness signals
• use futures or promises when a result or exception must cross an asynchronous boundary
• use atomics for isolated low-level state, not as a first resort for complex coordination