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.

Small worked example

#include <condition_variable>
#include <mutex>
#include <queue>

std::mutex guard;
std::condition_variable cv;
std::queue<int> jobs;

int pop_job() {
	std::unique_lock lock(guard);
	cv.wait(lock, [] { return !jobs.empty(); });
	int job = jobs.front();
	jobs.pop();
	return job;
}

This is the classic mutex-plus-condition-variable pairing: the mutex protects the queue invariant, and the condition variable lets workers sleep until that invariant changes.

Selection guide

• use mutex plus condition_variable for shared-state waiting on predicates
• use shared_mutex when reads dominate and concurrent readers matter more than simple locking
• use binary_semaphore or counting_semaphore for permit-style coordination
• use latch or barrier when threads must reach a common phase point
• use future or promise when the handoff includes a result, exception, or completion state

Related pages

• C++ concurrency library
• Header reference: <thread>
• Header reference: <future>