All Concurrency Primitives

All Concurrency Primitives

A compact scan page for the main thread, lock, waiting, task, and atomic primitives in the C++ standard library.

How to use this reference page

Use reference pages to confirm names, categories, nearby facilities, and the constraints that matter before writing or reviewing code.

Scan the top of the page first to identify the primary types, functions, or algorithm families involved.
Use the nearby-page links when your question is really about a companion header, related algorithm family, or broader subsystem.
Validate tricky behavior with a small compileable example before relying on memory for details like invalidation, ordering, allocation, or lifetime rules.

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.

Example in practice

#include <thread>
#include <mutex>

int main() {
    std::mutex guard;
    std::jthread worker([&] {
        std::scoped_lock lock(guard);
    });
}