C++ Concurrency Library

C++ Concurrency Library

Threads, jthread, stop tokens, mutexes, atomics, futures, semaphores, latches, barriers, and the main coordination tools in the 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.

C++ Concurrency Library

Threads and cancellation

std::thread: raw thread object that must be joined or detached
std::jthread: joining thread with cooperative cancellation support
std::stop_source, std::stop_token, std::stop_callback

Mutual exclusion and locking

std::mutex, std::recursive_mutex, std::timed_mutex
std::shared_mutex, std::shared_timed_mutex
std::lock_guard, std::unique_lock, std::scoped_lock, std::shared_lock

Waiting and coordination

std::condition_variable, std::condition_variable_any
std::latch
std::barrier
std::counting_semaphore, std::binary_semaphore

Futures and task abstractions

std::future, std::shared_future
std::promise
std::packaged_task
std::async

Atomics

std::atomic<T>
specialized atomics and atomic operations
memory orders such as memory_order_relaxed, memory_order_acquire, memory_order_release, memory_order_seq_cst

Practical choice rules

prefer std::jthread when ownership and lifetime are local
use mutexes to protect invariants, not just individual variables
use condition variables for sleeping until a predicate becomes true
use semaphores for capacity limits
use latches and barriers for staged parallel work
keep lock-free code small, deliberate, and well-tested

Example in practice

#include <thread>
#include <mutex>

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