std::stop_callback

Определён в заголовочном файле `<stop_token>`
template< class Callback > class stop_callback;		(начиная с C++20)

Шаблон класса stop_callback предоставляет тип объекта RAII, регистрирующий функцию обратного вызова для связанного объекта std::stop_token, благодаря чему функция обратного вызова будет вызвана, когда для связанного с std::stop_token объекта std::stop_source будет запрошена остановка.

Функции обратного вызова, зарегистрированные с помощью конструктора stop_callback, вызываются либо в том же потоке, который успешно вызывает request_stop() для объекта std::stop_source, связанного с std::stop_token объекта stop_callback; либо, если остановка уже была запрошена до регистрации в конструкторе, функция обратного вызова вызывается в потоке, создающем stop_callback.

Для одного и того же std::stop_token может быть создано несколько объектов stop_callback одновременно из одного или разных потоков. Порядок их выполнения не гарантируется, но они будут вызваны синхронно; исключение составляют объекты stop_callback, созданные после того, как для std::stop_token уже была запрошена остановка, как описано выше.

Если вызов функции обратного вызова завершается исключением, вызывается std::terminate.

std::stop_callback не удовлетворяет требованиям CopyConstructible, CopyAssignable, MoveConstructible и MoveAssignable.

Тип параметра шаблона Callback должен удовлетворять требованиям invocable и destructible. Любое возвращаемое значение игнорируется.

Типы-члены

Тип	Определение
`callback_type`	`Callback`

Функции-члены

(конструктор)	создаёт новый объект `stop_callback` (функция-член класса)
(деструктор)	уничтожает объект `stop_callback` (функция-член класса)
operator= [удалён]	`stop_callback` не поддерживает присваивание (функция-член класса)

Руководства по выводу типов

Пример

#include <chrono>
#include <condition_variable>
#include <iostream>
#include <mutex>
#include <sstream>
#include <thread>

using namespace std::chrono_literals;

// Use a helper class for atomic std::cout streaming.
class Writer
{
    std::ostringstream buffer;
public:
    ~Writer()
    {
        std::cout << buffer.str();
    }
    Writer& operator<<(auto input)
    {
        buffer << input;
        return *this;
    }
};

int main()
{
    // A worker thread.
    // It will wait until it is requested to stop.
    std::jthread worker([] (std::stop_token stoken)
    {
        Writer() << "Worker thread's id: " << std::this_thread::get_id() << '\n';
        std::mutex mutex;
        std::unique_lock lock(mutex);
        std::condition_variable_any().wait(lock, stoken,
            [&stoken] { return stoken.stop_requested(); });
    });

    // Register a stop callback on the worker thread.
    std::stop_callback callback(worker.get_stop_token(), []
    {
        Writer() << "Stop callback executed by thread: "
            << std::this_thread::get_id() << '\n';
    });

    // Stop_callback objects can be destroyed prematurely to prevent execution.
    {
        std::stop_callback scoped_callback(worker.get_stop_token(), []
        {
            // This will not be executed.
            Writer() << "Scoped stop callback executed by thread: "
                << std::this_thread::get_id() << '\n';
        });
    }

    // Demonstrate which thread executes the stop_callback and when.
    // Define a stopper function.
    auto stopper_func = [&worker]
    {
        if (worker.request_stop())
            Writer() << "Stop request executed by thread: "
                << std::this_thread::get_id() << '\n';
        else
            Writer() << "Stop request not executed by thread: "
                << std::this_thread::get_id() << '\n';
    };

    // Let multiple threads compete for stopping the worker thread.
    std::jthread stopper1(stopper_func);
    std::jthread stopper2(stopper_func);
    stopper1.join();
    stopper2.join();

    // After a stop has already been requested,
    // a new stop_callback executes immediately.
    Writer() << "Main thread: " << std::this_thread::get_id() << '\n';
    std::stop_callback callback_after_stop(worker.get_stop_token(), []
    {
        Writer() << "Stop callback executed by thread: "
            << std::this_thread::get_id() << '\n';
    });
}

Возможный вывод:

Worker thread's id: 140460265039616
Stop callback executed by thread: 140460256646912
Stop request executed by thread: 140460256646912
Stop request not executed by thread: 140460248254208
Main thread: 140460265043776
Stop callback executed by thread: 140460265043776

© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
https://en.cppreference.com/cpp/thread/stop_callback