C++ Multithreading: Relaxed Ordering and the Torn Read Bug

Modern CPUs ship with 8, 16, even 64 cores, and most C++ programs use exactly one of them. That's like buying a Formula 1 car and driving it in second gear. Multithreading is how you put all that hardware to work — and in latency-sensitive systems like game engines, financial trading platforms, and real-time data pipelines, it's the difference between a product that ships and one that gets cancelled.

The problem multithreading solves is deceptively simple: some work can happen in parallel, so make it happen in parallel. But the devil is in the details. Shared mutable state, non-obvious memory visibility, spurious wakeups, priority inversion, and the C++ memory model's acquire-release semantics make this one of the hardest topics in the language to get right in production. Getting it wrong doesn't just cause bugs — it causes bugs that only appear under load, on specific hardware, once a month.

By the end of this article you'll understand how std::thread works under the hood, why std::mutex costs what it costs, when to reach for std::atomic instead, how condition variables enable efficient thread coordination without spinning, and what the C++ memory model actually guarantees. You'll leave with patterns you can deploy in real codebases today.

What Is Multithreading in C++?

Multithreading means executing multiple sequences of instructions concurrently. In C++, the standard library provides std::thread since C++11, which wraps the OS thread API (pthreads on Linux, WinThreads on Windows). Each std::thread object represents a single thread of execution. You launch a thread by passing a callable — a function, lambda, or functor — to the constructor.

The key trade-off: threads share the same address space. This makes data sharing cheap (just a pointer) but introduces race conditions when two threads modify the same data without synchronization. Here's the minimal example that actually runs work in parallel:

#include <iostream>
#include <thread>
#include <vector>

namespace io::thecodeforge::multithreading {

void worker(int id) {
    std::cout << "Thread " << id << " running on core "
              << sched_getcpu() << '\n';
}

void launch_workers() {
    std::vector<std::thread> threads;
    for (int i = 0; i < 4; ++i)
        threads.emplace_back(worker, i);
    for (auto& t : threads)
        t.join();
}

} // namespace io::thecodeforge::multithreading

int main() {
    io::thecodeforge::multithreading::launch_workers();
}

Callable Types for std::thread Constructor: Comparison Table

std::thread can be constructed with any callable type. The table below compares the four common categories: free functions, lambda expressions, functors (function objects), and member function pointers. Each has distinct syntax and typical use cases.

Here's a complete demonstration of all four:

#include <iostream>
#include <thread>

namespace io::thecodeforge::multithreading {

// 1. Free function
void free_func(int x) {
    std::cout << "Free function: " << x << '\n';
}

// 2. Functor
struct Functor {
    void operator()(int x) const {
        std::cout << "Functor: " << x << '\n';
    }
};

// 3. Class with member function
class Worker {
public:
    void method(int x) const {
        std::cout << "Member function: " << x << '\n';
    }
};

void launch_all() {
    // Free function
    std::thread t1(free_func, 1);
    // Lambda
    std::thread t2([](int x){ std::cout << "Lambda: " << x << '\n'; }, 2);
    // Functor
    Functor f;
    std::thread t3(f, 3);
    // Member function
    Worker w;
    std::thread t4(&Worker::method, &w, 4);

    t1.join(); t2.join(); t3.join(); t4.join();
}

} // namespace

int main() {
    io::thecodeforge::multithreading::launch_all();
}

Mutexes: The Last Line of Defense Against Races

A mutex (mutual exclusion) ensures that only one thread executes a critical section at a time. C++ offers std::mutex

#include <iostream>
#include <thread>
#include <mutex>
#include <vector>

namespace io::thecodeforge::multithreading {

class SafeCounter {
    int counter_ = 0;
    std::mutex mtx_;
public:
    void increment() {
        std::lock_guard<std::mutex> lock(mtx_);
        ++counter_;
    }
    int get() const {
        std::lock_guard<std::mutex> lock(mtx_);
        return counter_;
    }
};

void test() {
    SafeCounter sc;
    std::vector<std::thread> threads;
    for (int i = 0; i < 100; ++i)
        threads.emplace_back(&SafeCounter::increment, &sc);
    for (auto& t : threads) t.join();
    std::cout << "Final count: " << sc.get() << '\n';
}

} // namespace

int main() {
    io::thecodeforge::multithreading::test();
}

Mutex Types Comparison Table

C++ provides several mutex types tailored for specific scenarios. The table below compares std::mutex, std::timed_mutex, std::shared_mutex, and std::recursive_mutex across key attributes.

std::shared_mutex is especially useful for read-heavy workloads where multiple readers can proceed simultaneously without blocking each other. Here's an example of using std::shared_mutex with a reader-writer lock pattern:

#include <iostream>
#include <shared_mutex>
#include <thread>
#include <vector>

namespace io::thecodeforge::multithreading {

class ThreadSafeCache {
    mutable std::shared_mutex mtx_;
    int cached_value_ = 0;
public:
    void write(int val) {
        std::unique_lock lock(mtx_);
        cached_value_ = val;
    }
    int read() const {
        std::shared_lock lock(mtx_);
        return cached_value_;
    }
};

void test() {
    ThreadSafeCache cache;
    std::thread writer([&]{ cache.write(42); });
    std::vector<std::thread> readers;
    for (int i = 0; i < 10; ++i)
        readers.emplace_back([&]{ std::cout << cache.read() << ' '; });
    writer.join();
    for (auto& t : readers) t.join();
}

} // namespace

int main() {
    io::thecodeforge::multithreading::test();
}

Atomics: Lock-Free Data Sharing Done Right

std::atomic<T> provides lock-free operations for integer types (and pointers) on most platforms. Atomics use CPU instructions like x86 LOCK prefix or CMPXCHG to ensure atomic reads and writes without a mutex. They also control memory ordering to enforce visibility guarantees.

The critical difference: a normal variable can be torn during a read if another thread writes simultaneously. An atomic variable guarantees that loads and stores are indivisible. But correctness also requires proper memory ordering — the default std::memory_order_seq_cst is safest but slowest.

#include <iostream>
#include <atomic>
#include <thread>
#include <vector>

namespace io::thecodeforge::multithreading {

std::atomic<int> counter{0};

void increment() {
    // memory_order_relaxed is sufficient for a counter that's eventually consistent
    counter.fetch_add(1

Condition Variables: Efficient Thread Notification

A condition variable allows one thread to wait for a condition to become true without busy-waiting. std::condition_variable must be paired with a std::unique_lock<std::mutex> and a predicate. The pattern: the waiting thread calls wait(lock, predicate), which atomically unlocks the mutex and blocks. When another thread calls notify_one() or notify_all(), the waiting thread re-acquires the mutex and re-checks the predicate.

The predicate is critical — it prevents spurious wakeups (which occur even on POSIX systems). Without a predicate, the waiting thread might wake up even though the condition isn't true, leading to logic bugs.

#include <iostream>
#include <condition_variable>
#include <mutex>
#include <queue>
#include <thread>

namespace io::thecodeforge::multithreading {

std::queue<int> messages;
std::mutex mtx;
std::condition_variable cv;

void producer() {
    for (int i = 0; i < 10; ++i) {
        std::this_thread::sleep_for(std::chrono::milliseconds(50));
        {
            std::lock_guard<std::mutex> lock(mtx);
            messages.push(i);
        }
        cv.notify_one();
    }
}

void consumer() {
    while (true) {
        std::unique_lock<std::mutex> lock(mtx);
        cv.wait(lock, []{ return !messages.empty(); });
        int val = messages.front();
        messages.pop();
        lock.unlock();
        std::cout << "Consumed: " << val << '\n';
        if (val == 9) break;
    }
}

} // namespace

int main() {
    std::thread p(io::thecodeforge::multithreading::producer);
    std::thread c(io::thecodeforge::multithreading::consumer);
    p.join(); c.join();
}

Launching Asynchronous Tasks with std::async and std::future

std::async provides a higher-level interface for parallel tasks. It returns a std::future which will hold the result once the task completes. Unlike std::thread, you don't need to manage thread lifetime manually — the future's destructor will join or detach the task depending on the launch policy.

The default policy (std::launch::async | std::launch::deferred) lets the implementation choose, which can lead to surprising sequential execution. Always specify std::launch::async explicitly if you want parallelism.

#include <iostream>
#include <future>
#include <chrono>

namespace io::thecodeforge::multithreading {

int slow_square(int x) {
    std::this_thread::sleep_for(std::chrono::seconds(1));
    return x * x;
}

void example() {
    // Launch two tasks asynchronously
    std::future<int> f1 = std::async(std::launch::async, slow_square, 5);
    std::future<int> f2 = std::async(std::launch::async, slow_square, 7);

    // Do other work while tasks run...
    std::cout << "Waiting for results...\n";

    // Get results (blocks until each completes)
    int result1 = f1.get();
    int result2 = f2.get();

    std::cout << "Results: " << result1 << ", " << result2 << '\n';
}

} // namespace

int main() {
    io::thecodeforge::multithreading::example();
}

Memory Ordering and the C++ Memory Model

The C++ memory model defines how operations on different threads become visible to each other. Without proper ordering, a thread might see stale values or operations appear to happen in a different order than written. The model is built on happens-before relationships: operation A happens-before operation B if B must see A's effects.

std::atomic provides six memory order modes: memory_order_relaxed (no ordering constraints), memory_order_consume (deprecated), memory_order_acquire (reads cannot be reordered before this point), memory_order_release (writes cannot be reordered after this point), memory_order_acq_rel (acquire+release for read-modify-write), and memory_order_seq_cst (sequential consistency — default). Acquire-release pairs create happens-before edges.

#include <atomic>
#include <thread>
#include <cassert>

namespace io::thecodeforge::multithreading {

std::atomic<int> data{0};
std::atomic<int> flag{0};

void writer() {
    data.store(42

Thread Synchronization Primitives Summary Table

C++ provides a rich set of synchronization primitives for different coordination patterns. The table below summarizes the most common ones, including those from C++11 (mutex, atomic, condition_variable, future) and newer additions from C++20 (semaphore, barrier, latch).

For most applications, the first five primitives cover 90% of needs. The C++20 primitives reduce boilerplate in multi-phase parallel algorithms.

Thread Pool Pattern: Capping Concurrency

Creating and destroying threads for every task has significant overhead and can overwhelm the system. A thread pool maintains a fixed number of worker threads that continuously pull tasks from a shared queue. This caps concurrency, reduces latency, and prevents resource exhaustion.

Below is a minimal thread pool implementation using std::thread, std::mutex, std::condition_variable, and std::queue. Workers run an infinite loop: they wait for a task on the queue, execute it, then check for new work. The pool enqueues tasks via push_task().

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <queue>
#include <functional>
#include <vector>

namespace io::thecodeforge::multithreading {

class ThreadPool {
    std::vector<std::thread> workers;
    std::queue<std::function<void()>> tasks;
    std::mutex mtx;
    std::condition_variable cv;
    bool stop = false;

public:
    explicit ThreadPool(size_t count) {
        for (size_t i = 0; i < count; ++i)
            workers.emplace_back([this] {
                while (true) {
                    std::function<void()> task;
                    {
                        std::unique_lock lock(mtx);
                        cv.wait(lock, [this]{ return stop || !tasks.empty(); });
                        if (stop && tasks.empty()) return;
                        task = std::move(tasks.front());
                        tasks.pop();
                    }
                    task();
                }
            });
    }

    ~ThreadPool() {
        {
            std::lock_guard lock(mtx);
            stop = true;
        }
        cv.notify_all();
        for (auto& w : workers) w.join();
    }

    template <class F>
    void push_task(F&& f) {
        {
            std::lock_guard lock(mtx);
            tasks.emplace(std::forward<F>(f));
        }
        cv.notify_one();
    }
};

void example() {
    ThreadPool pool(4);  // 4 workers
    for (int i = 0; i < 10; ++i)
        pool.push_task([i] {
            std::cout << "Task " << i << " on thread "
                      << std::this_thread::get_id() << '\n';
        });
    std::this_thread::sleep_for(std::chrono::seconds(1));
} // pool destructor joins all threads

} // namespace

int main() {
    io::thecodeforge::multithreading::example();
}

Thread Detachment: The Fire-and-Forget Footgun

You don't always want to join. Sometimes you need a thread to live on its own — logging, monitoring, a background heartbeat — while your main thread moves on. That's std::thread::detach().

Detaching means you relinquish ownership. The OS takes over, and the thread runs independently until it finishes. You can't join it anymore. You can't check its status. The thread is a ghost.

Production reality: detach is dangerous if your thread accesses stack variables from the parent scope. The parent might unwind before the thread reads them. Classic use-after-free. If you detach, make sure your thread owns its data or uses heap-allocated resources managed by std::shared_ptr.

Never detach without understanding that joinable() will return false afterward. Calling join on a detached thread crashes your program. The rule: attach your thread to a scope (join) or detach it explicitly. Either way, one of them must happen. No exceptions.

// io.thecodeforge — c-cpp tutorial
#include <thread>
#include <iostream>
#include <chrono>

void backgroundLogger() {
    for (int i = 0; i < 3; ++i) {
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
        std::cout << "Log: heartbeat " << i << "\n";
    }
}

int main() {
    std::thread logger(backgroundLogger);
    logger.detach();  // fire and forget

    // Main thread continues immediately
    std::cout << "Main continues...\n";
    std::this_thread::sleep_for(std::chrono::milliseconds(350));
    std::cout << "Main done. Logger might still be running.\n";
    return 0;
}

Thread IDs: Identifying Your Workers in the Zoo

When you have 20 worker threads hammering a queue, you need to know which thread is printing that garbled log line. std::this_thread::get_id() returns a unique std::thread::id for every running thread.

You can store IDs in a set, print them for debugging, or use them as keys in thread-local storage maps. They're hashable, comparable, and copyable. They're your threads' fingerprints.

Senior trade secret: don't rely on thread IDs for security or persistence. The OS can recycle IDs after threads exit. They're unique only during the thread's lifetime. Use them for logging, profiling, or ensuring a critical section is only entered by one specific thread (bad idea — use a mutex instead).

Also: std::thread::id has a default constructor that yields a special 'not-a-thread' ID. Useful for optional thread ownership patterns. Compare with == or sort them into maps. It's a proper value type.

// io.thecodeforge — c-cpp tutorial
#include <iostream>
#include <thread>
#include <vector>

void work(int taskId) {
    auto id = std::this_thread::get_id();
    std::cout << "Task " << taskId << " on thread " << id << "\n";
}

int main() {
    std::vector<std::thread> workers;
    for (int i = 0; i < 4; ++i) {
        workers.emplace_back(work, i);
    }

    std::cout << "Main thread id: " << std::this_thread::get_id() << "\n";

    for (auto& t : workers) {
        t.join();
    }
    return 0;
}

Callables Beyond Functions: Lambdas, Functors, and Member Functions

You're not limited to plain functions when constructing std::thread. The constructor accepts anything callable — lambdas, function objects, member functions, even std::bind results. This shapes how you capture state and manage lifetimes.

Lambdas are the default choice in modern C++. They capture variables by value or reference. Capture by reference is dangerous if the lambda executes after the captured variable goes out of scope. Capture by value is safe but copies everything. Move semantics ([ptr = std::move(ptr)]) avoid copying while being safe.

Member functions require a pointer to the object and the arguments. Syntax: std::thread(&Class::method, &instance, args...). The pointer is passed as the second argument. Be careful — if the instance gets destroyed before the thread finishes, you're dereferencing a ghost.

Functor classes (operator()) let you pack complex state into one object. They're slower to write but useful when you need RAII wrappers for thread resources. Pick the callable type that makes the lifetime contract explicit: lambda for quick one-offs, functor for reusable thread tasks, member function for OOP integration.

// io.thecodeforge — c-cpp tutorial
#include <iostream>
#include <thread>

class Worker {
public:
    void process(int id) { 
        std::cout << "Member on " << id << "\n"; 
    }
};

struct Functor {
    void operator()(int x) { 
        std::cout << "Functor got " << x << "\n"; 
    }
};

int main() {
    Worker w;
    std::thread t1(&Worker::process, &w, 1);  // member
    
    Functor f;
    std::thread t2(f, 2);  // functor
    
    std::thread t3([](int x) {  // lambda
        std::cout << "Lambda with " << x << "\n";
    }, 3);

    t1.join(); t2.join(); t3.join();
    return 0;
}

Context Switch: The Performance Tax You Can't Dodge

A context switch is when the OS yanks a thread off the CPU and piles another one on. It's not free. The kernel saves registers, flushes TLBs, reloads new state — that's microseconds of dead time. Do that thousands of times per second and your throughput tanks.

Why should you care? Because most devs think "more threads = faster." Nope. If your threads outnumber CPU cores and they fight over mutexes, you burn cycles on switching instead of working. The fix: keep thread count close to core count. Use a thread pool (already covered) and batch work into chunks big enough to amortize the switch cost. Measure context switch rate with perf or top -H. If it's spiking, your design is wrong.

Production rule: one context switch per chunk of real work isn't a problem. A hundred switches per lock acquisition? You're leaking throughput.

// io.thecodeforge — c-cpp tutorial
// Demo showing high context switch overhead

#include <thread>
#include <vector>
#include <mutex>
#include <iostream>

std::mutex m;
int shared = 0;

void hammer() {
    for (int i = 0; i < 100000; ++i) {
        std::lock_guard<std::mutex> lg(m);
        ++shared;  // Tiny critical section
    }
}

int main() {
    const int num_threads = 8;
    std::vector<std::thread> threads;
    for (int i = 0; i < num_threads; ++i)
        threads.emplace_back(hammer);
    for (auto& t : threads) t.join();
    std::cout << "Final count: " << shared << std::endl;
    return 0;
}

Example 1: Email Server — Multithreaded Queue Popping

An email server receives thousands of messages per second. Each message needs parsing, spam checking, and routing to a mailbox. You cannot block the network listener for any of that. So you push the raw message onto a concurrent queue and let worker threads pop and process.

The pattern: one producer thread (or more from I/O), N consumer threads. The queue protects itself with a mutex and condition variable (see previous sections). The key insight: never hold the queue lock while processing. Pop the item, release the lock, then do the heavy lifting. Holding the lock across disk I/O or spam filtering turns your concurrency into a serial bottleneck.

This example shows a bounded queue with a single producer and two consumers. In production you'd tune consumer count to core count and measure queue depth to avoid memory blowup.

// io.thecodeforge — c-cpp tutorial
// Minimal email server: push raw emails, pop and process

#include <queue>
#include <mutex>
#include <condition_variable>
#include <thread>
#include <iostream>
#include <string>

struct Inbox { int id; std::string raw; };

class MailQueue {
    std::queue<Inbox> q_;
    std::mutex m_;
    std::condition_variable cv_;
public:
    void push(Inbox msg) {
        std::lock_guard<std::mutex> lk(m_);
        q_.push(std::move(msg));
        cv_.notify_one();
    }
    Inbox pop() {
        std::unique_lock<std::mutex> lk(m_);
        cv_.wait(lk, [this]{ return !q_.empty(); });
        Inbox msg = std::move(q_.front());
        q_.pop();
        return msg;
    }
};

int main() {
    MailQueue mq;
    auto worker = [&]{ while(true) {
        auto msg = mq.pop();
        std::cout << "Processing msg " << msg.id << std::endl;
    }};
    auto producer = [&]{ for(int i=0;;++i)
        mq.push({i, "raw email"});
    };
    std::thread t1(worker), t2(worker);
    producer();
}

C++20: std::jthread and Cooperative Cancellation

C++20 introduced std::jthread (joining thread) as a safer alternative to std::thread. Unlike std::thread, which requires explicit join() or detach() to avoid resource leaks, std::jthread automatically joins in its destructor, preventing accidental detachment. More importantly, std::jthread supports cooperative cancellation via a built-in std::stop_token. This allows you to request a thread to stop gracefully without resorting to dangerous practices like std::thread::detach() or platform-specific thread termination.

To use cooperative cancellation, the thread function accepts a std::stop_token parameter. The main thread can then call request_stop() on the std::jthread object, which sets the stop token's stop state. The thread function periodically checks stop_requested() on the token and exits cleanly when requested. This mechanism is particularly useful for long-running worker threads that need to be shut down gracefully during application shutdown or when tasks are canceled.

Example: A worker thread that processes data until a stop is requested.

```cpp #include #include #include

void worker(std::stop_token stoken) { while (!stoken.stop_requested()) { std::cout << "Working... "; std::this_thread::sleep_for(std::chrono::milliseconds(500)); } std::cout << "Worker stopped gracefully. "; }

int main() { std::jthread jt(worker); std::this_thread::sleep_for(std::chrono::seconds(2)); jt.request_stop(); // Request cooperative stop // jt destructor joins automatically return 0; } ```

This eliminates the need for manual flags or condition variables for cancellation, reducing boilerplate and potential race conditions. std::jthread is the recommended choice for new C++20 code that requires thread management with cancellation support.

#include <iostream>
#include <thread>
#include <chrono>

void worker(std::stop_token stoken) {
    while (!stoken.stop_requested()) {
        std::cout << "Working...\n";
        std::this_thread::sleep_for(std::chrono::milliseconds(500));
    }
    std::cout << "Worker stopped gracefully.\n";
}

int main() {
    std::jthread jt(worker);
    std::this_thread::sleep_for(std::chrono::seconds(2));
    jt.request_stop();
    return 0;
}

C++20: std::counting_semaphore, std::barrier, std::latch

C++20 introduced three new synchronization primitives: std::counting_semaphore, std::barrier, and std::latch. These complement existing tools like mutexes and condition variables, offering more specialized and efficient coordination patterns.

std::counting_semaphore is a lightweight semaphore that controls access to a shared resource with a counter. It supports acquire() (decrement, block if zero) and release() (increment). Unlike condition variables, semaphores are simpler and avoid spurious wakeups. They are ideal for producer-consumer scenarios with multiple resources.

std::barrier synchronizes a group of threads at a barrier point. Each thread calls arrive_and_wait(), and when all threads have arrived, the barrier resets and threads proceed. Optionally, a completion function runs at each barrier phase. This is useful for iterative algorithms where threads must synchronize after each step.

std::latch is a single-use barrier. It is initialized with a count. Threads call count_down() to decrement the count, and wait() blocks until the count reaches zero. Unlike std::barrier, a latch cannot be reused. It is perfect for one-time synchronization, such as waiting for multiple tasks to complete before proceeding.

Example: Using std::latch to wait for worker threads to finish initialization.

```cpp #include #include #include #include

void worker(std::latch& latch, int id) { std::this_thread::sleep_for(std::chrono::milliseconds(100 * id)); std::cout << "Worker " << id << " ready. "; latch.count_down(); }

int main() { const int num_workers = 3; std::latch latch(num_workers); std::vector threads; for (int i = 0; i < num_workers; ++i) { threads.emplace_back(worker, std::ref(latch), i); } latch.wait(); // Wait for all workers std::cout << "All workers ready. Proceeding. "; return 0; } ```

These primitives reduce boilerplate and improve performance compared to hand-rolled solutions with mutexes and condition variables.

#include <iostream>
#include <thread>
#include <latch>
#include <vector>

void worker(std::latch& latch, int id) {
    std::this_thread::sleep_for(std::chrono::milliseconds(100 * id));
    std::cout << "Worker " << id << " ready.\n";
    latch.count_down();
}

int main() {
    const int num_workers = 3;
    std::latch latch(num_workers);
    std::vector<std::jthread> threads;
    for (int i = 0; i < num_workers; ++i) {
        threads.emplace_back(worker, std::ref(latch), i);
    }
    latch.wait();
    std::cout << "All workers ready. Proceeding.\n";
    return 0;
}

std::async vs std::thread vs std::jthread: Decision Guide

Choosing between std::async, std::thread, and std::jthread depends on your concurrency needs. Here's a decision guide to help you pick the right tool.

std::async is the highest-level abstraction. It launches a task asynchronously and returns a std::future to retrieve the result. It manages thread creation and destruction automatically, and the runtime may decide to run the task synchronously (if std::launch::deferred is used) or in a new thread. Use std::async when you need a simple way to run a function in the background and get its return value, especially for fire-and-forget tasks or when you don't need fine-grained control over thread lifetime.

std::thread is a low-level primitive that creates a new OS thread. You must explicitly join() or detach() it. It gives you full control over thread creation, but you are responsible for resource management. Use std::thread when you need to manage thread lifetime manually, or when you need a persistent thread for a long-running task (e.g., a dedicated I/O thread). However, prefer std::jthread in C++20 for automatic joining.

std::jthread (C++20) is like std::thread but automatically joins on destruction and supports cooperative cancellation via std::stop_token. Use std::jthread as a drop-in replacement for std::thread in modern C++ code. It is ideal for worker threads that need to be stopped gracefully, or when you want to avoid forgetting to join.

Example: Comparing the three approaches for a simple task.

```cpp // std::async std::future fut = std::async(std::launch::async, []{ return 42; }); int result = fut.get();

// std::thread std::thread t([](int& res){ res = 42; }, std::ref(result)); t.join();

// std::jthread std::jthread jt([](std::stop_token st, int& res){ while (!st.stop_requested()) { / work / } res = 42; }, std::ref(result)); jt.request_stop(); ```

In summary, prefer std::async for simplicity, std::jthread for safety and cancellation, and std::thread only when you need explicit control (and are careful to join).

#include <iostream>
#include <future>
#include <thread>

int main() {
    // std::async
    std::future<int> fut = std::async(std::launch::async, []{ return 42; });
    std::cout << "async result: " << fut.get() << std::endl;

    // std::thread
    int result_thread = 0;
    std::thread t([&result_thread]{ result_thread = 42; });
    t.join();
    std::cout << "thread result: " << result_thread << std::endl;

    // std::jthread
    int result_jthread = 0;
    std::jthread jt([&result_jthread]{ result_jthread = 42; });
    // jt destructor joins automatically
    std::cout << "jthread result: " << result_jthread << std::endl;

    return 0;
}