std::thread and joining every thread you start

Understanding std::thread and joining every thread you start

A std::thread object is a handle to a running function, not the function itself. The moment the constructor returns, a second thread is already executing your callable on its own stack while main carries on independently, so you now have two lifetimes to track: the scope of the handle object and the execution of the callable. join() ties them back together: it blocks the calling thread until the callable has returned, then releases the handle so joinable() reports false.

That is why the destructor is so strict. If a std::thread is destroyed while joinable() is still true, the destructor calls std::terminate: no unwinding, no message of yours, the process just dies. Both friendlier-sounding alternatives are worse, because silently joining would make an innocent closing brace block for an unbounded time, and silently detaching would leave a thread reading the locals of the frame being destroyed. The language forces you to state which one you meant, and that is what joining every thread you start really amounts to.

The arguments you pass to the constructor are decay-copied into storage owned by the new thread and then handed to the callable, so a thread never refers to a caller variable unless you ask for it with std::ref, and an array or string literal collapses to a pointer. Anything the thread does reach through a reference, pointer, or by-reference capture must stay alive until the join, which is another reason to join in the scope that owns the data. The join pays you back with visibility: everything the thread wrote before returning is observable by the joining thread afterwards, so launch, join, then read needs no extra machinery.

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

// Each worker writes only to its own slot, so the slots need no locking.
void sum_range(int from, int to, long long& out) {
    long long total = 0;
    for (int i = from; i <= to; ++i) total += i;
    out = total;
}

int main() {
    const int workers = 4;
    std::vector<long long> results(workers, 0);
    std::vector<std::thread> pool;
    pool.reserve(workers);

    for (int w = 0; w < workers; ++w) {
        int from = w * 250 + 1;
        // std::ref is required: thread arguments are copied by default.
        pool.emplace_back(sum_range, from, from + 249, std::ref(results[w]));
    }

    std::cout << std::boolalpha;
    std::cout << "launched " << pool.size() << " threads\n";
    std::cout << "pool[0].joinable() before join: " << pool[0].joinable() << "\n";

    for (std::thread& t : pool) {
        t.join();  // blocks until that worker's function has returned
    }

    std::cout << "pool[0].joinable() after join:  " << pool[0].joinable() << "\n";

    long long total = 0;
    for (int w = 0; w < workers; ++w) {
        std::cout << "worker " << w << " summed " << results[w] << "\n";
        total += results[w];
    }
    std::cout << "grand total " << total << "\n";
}

Worked examples

#include <functional>
#include <iostream>
#include <string>
#include <thread>

void mutate(std::string label, int& counter) {
    label += "-touched";  // edits the thread's own copy
    counter += 1;         // edits main's variable through the reference
}

int main() {
    std::string label = "job";
    int counter = 0;

    std::thread t(mutate, label, std::ref(counter));
    t.join();

    std::cout << "label   = " << label << "\n";
    std::cout << "counter = " << counter << "\n";
}

#include <iostream>
#include <stdexcept>
#include <thread>

struct joining_thread {
    std::thread t;
    ~joining_thread() {
        if (t.joinable()) {
            t.join();
            std::cout << "destructor joined the worker\n";
        }
    }
};

int main() {
    int computed = 0;
    try {
        joining_thread guard{std::thread([&computed] {
            for (int i = 1; i <= 10; ++i) computed += i;
        })};
        std::cout << "worker launched\n";
        throw std::runtime_error("failure after launch");
    } catch (const std::exception& e) {
        std::cout << "caught: " << e.what() << "\n";
    }
    std::cout << "computed = " << computed << "\n";
}

#include <iostream>
#include <thread>
#include <utility>

int main() {
    std::thread worker([] { /* trivial work, may finish immediately */ });

    std::cout << std::boolalpha;
    std::cout << "worker before move: " << worker.joinable() << "\n";

    std::thread owner = std::move(worker);  // handle transferred, no new thread
    std::cout << "worker after move:  " << worker.joinable() << "\n";
    std::cout << "owner  after move:  " << owner.joinable() << "\n";

    owner.join();
    std::cout << "owner  after join:  " << owner.joinable() << "\n";
}

Important notes

Common mistakes

Try it yourself