Concurrency

Basic thread creation

std::thread worker([] {
    do_work();
});
worker.join();

Mutex and lock guard

std::mutex m;
int counter = 0;

void increment() {
    std::lock_guard<std::mutex> lock(m);
    ++counter;
}

Condition variables

std::condition_variable cv;
std::mutex m;
bool ready = false;

Use cv.wait(lock, predicate) to avoid spurious wake-up bugs.

Atomics

std::atomic<int> count{0};
count.fetch_add(1, std::memory_order_relaxed);

Futures and async

auto future = std::async(std::launch::async, compute);
auto result = future.get();

Best-practice reminders

• Prefer message passing or task-based design over shared mutable state.
• Minimize lock scope.
• Never forget to join() or detach() a std::thread.
• Measure before parallelizing.

std::jthread and cancellation

std::jthread worker([](std::stop_token stop) {
    while (!stop.stop_requested()) {
        tick();
    }
});

• std::jthread joins automatically on destruction.
• Use std::stop_token for cooperative cancellation.

More synchronization tools

• std::shared_mutex: many readers, one writer.
• std::latch: one-shot coordination point.
• std::barrier: repeated phase synchronization.
• std::counting_semaphore: bound access to a resource pool.

Memory ordering guidance

• Default to the stronger default ordering until profiling and correctness demands otherwise.
• memory_order_relaxed is for counters and statistics, not for publishing complex state.
• Keep lock-free code small, reviewed, and tested under stress.