std::jthread + std::stop_token

std::jthread — обёртка над std::thread из <thread>, добавляющая ровно одну вещь: деструктор, который, если поток всё ещё joinable, сам вызывает request_stop(), а затем join(). std::stop_token/std::stop_source/std::stop_callback из <stop_token> — независимый, но тесно связанный механизм: функция потока может принимать std::stop_token первым параметром, а тело потока в цикле проверяет token.stop_requested() и завершается само, увидев запрос остановки.std::jthread is a wrapper over std::thread from <thread> that adds exactly one thing: a destructor that, if the thread is still joinable, calls request_stop() itself, followed by join(). std::stop_token/std::stop_source/std::stop_callback from <stop_token> is an independent but tightly related mechanism: a thread function can take a std::stop_token as its first parameter, and the thread body loops checking token.stop_requested(), finishing on its own once it sees the stop request.

Это подробно разобрано ещё в cpp11/thread.html (там же — «Своя реализация» thread pool, которая станет проще именно с jthread) и в cpp_concurrency.md (таблица thread vs jthread, путь std::thread → живой поток ОС через clone()). Здесь — краткая выжимка происхождения и механики, без повторения всего материала.This is covered in detail already in cpp11/thread.html (which also has the "Rolling your own" thread pool section, which gets simpler with jthread) and in cpp_concurrency.md (the thread vs jthread table, the path from std::thread to a live OS thread via clone()). Here is a short summary of the feature's origin and mechanics, without repeating all of that material.

std::atomic<bool> stop_flag{false};
std::thread t([&] {
    while (!stop_flag.load()) { /* работа *//* work */ }
});
// ... нужно не забыть:// ... mustn't forget:
stop_flag = true;
t.join();   // забыл — std::terminate в деструкторе thread// forget this — std::terminate in thread's destructor

std::jthread t([](std::stop_token st) {
    while (!st.stop_requested()) { /* работа *//* work */ }
});
// деструктор t сам вызовет request_stop() + join()// t's destructor calls request_stop() + join() on its own

jthread — чисто библиотечная RAII-обёртка, не отдельная модель исполнения: под капотом тот же нативный поток ОС, что и у std::thread (на Linux — тот же путь через pthread_create() → clone() с CLONE_VM, разобранный в cpp_concurrency.md). jthread не создаёт ничего похожего на "зелёный" или "лёгкий" поток — экономия исключительно в том, что RAII-обёртка сама делает то, что раньше приходилось писать вручную в деструкторе окружающего объекта.jthread is a purely library-level RAII wrapper, not a separate execution model: under the hood it's the same native OS thread as std::thread (on Linux, the same path through pthread_create() → clone() with CLONE_VM, covered in cpp_concurrency.md). jthread doesn't create anything resembling a "green" or "lightweight" thread — the savings come purely from an RAII wrapper doing automatically what previously had to be hand-written in the destructor of some surrounding object.

#include <thread>
#include <stop_token>

std::jthread t([](std::stop_token st) {
    while (!st.stop_requested()) {
        // работа, периодически проверяющая токен// work that periodically checks the token
    }
});
// при выходе из scope: t.request_stop(); t.join(); — автоматически// on leaving scope: t.request_stop(); t.join(); — automatically

stop_source — та сторона, что вызывает request_stop(); stop_token — та сторона, что проверяет stop_requested(); оба ссылаются на общее разделяемое состояние (похоже по духу на shared_ptr — увеличивается refcount, а не копируется флаг). stop_callback позволяет зарегистрировать функцию, вызываемую в момент request_stop(), а не только опрашивать флаг в цикле — полезно, если поток заблокирован на операции, которая сама не проверяет токен, но предоставляет способ её прервать через callback.stop_source is the side that calls request_stop(); stop_token is the side that checks stop_requested(); both reference shared underlying state (similar in spirit to shared_ptr — a refcount is incremented, not a flag copied). stop_callback lets you register a function invoked at the moment of request_stop(), rather than only polling a flag in a loop — useful when a thread is blocked on an operation that doesn't itself check the token, but offers a way to interrupt it via a callback.

Именно эту роль решает std::stop_callback в паре с condition_variable: поток спит на cv.wait() и не проснётся сам по себе только оттого, что кто-то вызвал request_stop() — нужно явно разбудить его. Регистрация stop_callback позволяет сделать это автоматически, без ручного протаскивания дополнительного флага "разбудить сейчас" через мьютекс.This is exactly the role std::stop_callback plays alongside a condition_variable: a thread sleeping on cv.wait() won't wake up on its own just because someone called request_stop() — it needs to be explicitly woken. Registering a stop_callback does this automatically, without manually threading an extra "wake up now" flag through a mutex.

#include <condition_variable>
#include <mutex>

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

std::jthread worker([&](std::stop_token st) {
    std::stop_callback wake_on_stop(st, [&] {
        cv.notify_all();   // вызывается автоматически в момент request_stop()// invoked automatically at the moment of request_stop()
    });

    std::unique_lock<std::mutex> lk(m);
    cv.wait(lk, [&] { return data_ready || st.stop_requested(); });
    // без stop_callback поток спал бы здесь до data_ready,// without the stop_callback the thread would sleep here until data_ready,
    // не замечая request_stop() до случайного следующего пробуждения// not noticing request_stop() until some unrelated next wakeup
});

• cppreference — std::jthread
• cppreference — std::stop_token
• WG21 P0660 — Stop Token and Joining Thread