All Synchronization Objects

All Synchronization Objects

A compact scan page for mutexes, condition variables, semaphores, latches, barriers, and async coordination objects 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 Synchronization Objects

Mutex and lock types

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

Condition-based waiting

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

Semaphores and phase coordination

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

Futures and promise-based synchronization

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

Practical rules

Use mutexes to protect invariants and condition variables to wait on predicates.
Use semaphores for capacity-style coordination.
Use futures and promises when a result or exception must cross an asynchronous boundary.

Example in practice

#include <mutex>
#include <condition_variable>
#include <thread>

int main() {
    std::mutex guard;
    std::condition_variable cv;
    bool ready = false;

    std::jthread worker([&] {
        std::scoped_lock lock(guard);
        ready = true;
        cv.notify_one();
    });

    std::unique_lock lock(guard);
    cv.wait(lock, [&] { return ready; });
    return 0;
}