Namespaces
Variants

std:: stop_callback

From cppreference.net
C++
Concurrency support library
Threads
(C++11)
(C++20)
(C++17) (C++17)
this_thread namespace
(C++11)
(C++11)
Cooperative cancellation
(C++20)
(C++26)
(C++26)
(C++20)
(C++26)
stop_callback
(C++20)
Mutual exclusion
Generic lock management
Condition variables
(C++11)
(C++11)
(C++11)
(C++11)
Semaphores
(C++20) (C++20)
Latches and Barriers
(C++20)
(C++20)
Futures
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
Safe reclamation
Hazard pointers
(C++26)
(C++26)
(C++26)
Atomic types
(C++11)
(C++20)
(C++11)
Initialization of atomic types
(C++11) (deprecated in C++20)
(C++11) (deprecated in C++20)
(C++11)
Memory ordering
(C++11)
(C++11) (deprecated in C++26)
(C++11)
(C++11)
Free functions for atomic operations
(C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11) (C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11)
(C++26) (C++26)
(C++26) (C++26)
(C++11)
(C++20) (C++20)
(C++20)
(C++20)
Free functions for atomic flags
(C++11) (C++11)
(C++11) (C++11)
(C++20) (C++20)
(C++20) (C++20)
(C++20)
(C++20)
std::stop_callback
定义于头文件 <stop_token>
template < class Callback >
class stop_callback ;
(C++20 起)

stop_callback 类模板提供了一个 RAII 对象类型，该类型为关联的 std::stop_token 对象注册回调函数，使得当关联的 std::stop_source 被请求停止时，该回调函数将被调用。

通过 stop_callback 构造函数注册的回调函数会在以下两种情况下被调用：要么在成功调用 std::stop_token 关联的 std::stop_source 的 request_stop ( ) 方法的同一线程中执行；要么如果在构造函数注册之前已经请求停止，则回调会在构造 stop_callback 的线程中执行。

可以为同一个 std::stop_token 创建多个 stop_callback ，这些回调可以从相同或不同的线程并发创建。不保证它们的执行顺序，但会以同步方式调用；除了先前所述的、在对 std::stop_token 已发出停止请求后构造的 stop_callback 之外。

如果回调函数的调用因异常退出，则会调用 std::terminate 。

std::stop_callback 不满足 可复制构造 、 可复制赋值 、 可移动构造 和 可移动赋值 的要求。

模板参数 Callback 类型必须同时满足 invocable 与 destructible 概念。其返回值将被忽略。

目录

成员类型

类型 定义
callback_type Callback

成员函数

构造新的 stop_callback 对象
(公开成员函数)
销毁 stop_callback 对象
(公开成员函数)
operator=
[deleted]
stop_callback 不可赋值
(公开成员函数)

推导指南

示例

运行此代码 
#include <chrono>
#include <condition_variable>
#include <iostream>
#include <mutex>
#include <sstream>
#include <thread>
using namespace std::chrono_literals;
// 使用辅助类实现原子性的 std::cout 流操作
class Writer
{
    std::ostringstream buffer;
public:
    ~Writer()
    {
        std::cout << buffer.str();
    }
    Writer& operator<<(auto input)
    {
        buffer << input;
        return *this;
    }
};
int main()
{
    // 工作线程
    // 将等待直到收到停止请求
    std::jthread worker([] (std::stop_token stoken)
    {
        Writer() << "工作线程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(); });
    });
    // 在工作线程上注册停止回调
    std::stop_callback callback(worker.get_stop_token(), []
    {
        Writer() << "停止回调由线程执行: "
            << std::this_thread::get_id() << '\n';
    });
    // stop_callback 对象可提前销毁以防止执行
    {
        std::stop_callback scoped_callback(worker.get_stop_token(), []
        {
            // 此处代码不会被执行
            Writer() << "作用域停止回调由线程执行: "
                << std::this_thread::get_id() << '\n';
        });
    }
    // 演示哪个线程在何时执行 stop_callback
    // 定义停止器函数
    auto stopper_func = [&worker]
    {
        if (worker.request_stop())
            Writer() << "停止请求由线程执行: "
                << std::this_thread::get_id() << '\n';
        else
            Writer() << "停止请求未由线程执行: "
                << std::this_thread::get_id() << '\n';
    };
    // 让多个线程竞争停止工作线程
    std::jthread stopper1(stopper_func);
    std::jthread stopper2(stopper_func);
    stopper1.join();
    stopper2.join();
    // 在停止请求已被发出后
    // 新的 stop_callback 会立即执行
    Writer() << "主线程: " << std::this_thread::get_id() << '\n';
    std::stop_callback callback_after_stop(worker.get_stop_token(), []
    {
        Writer() << "停止回调由线程执行: "
            << std::this_thread::get_id() << '\n';
    });
}

可能的输出： 

工作线程ID: 140460265039616
停止回调由线程执行: 140460256646912
停止请求由线程执行: 140460256646912
停止请求未由线程执行: 140460248254208
主线程: 140460265043776
停止回调由线程执行: 140460265043776