Namespaces
Variants

std:: stop_source

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

stop_source 类提供了发出停止请求的方法,例如用于 std::jthread 的取消操作。对一个 stop_source 对象发出的停止请求,对所有共享同一关联停止状态的 stop_source std::stop_token 均可见;任何为关联的 std::stop_token 注册的 std::stop_callback 将被调用,并且任何等待关联 std::stop_token std::condition_variable_any 对象将被唤醒。

一旦请求停止,该请求将无法撤销。额外的停止请求不会产生任何效果。

目录

成员函数

构造新的 stop_source 对象
(公开成员函数)
析构 stop_source 对象
(公开成员函数)
赋值 stop_source 对象
(公开成员函数)
修改器
对关联的停止状态发起停止请求(如果存在)
(公开成员函数)
交换两个 stop_source 对象
(公开成员函数)
观察器
返回关联停止状态的 stop_token
(公开成员函数)
检查关联停止状态是否已被请求停止
(公开成员函数)
检查关联停止状态是否可被请求停止
(公开成员函数)

非成员函数

(C++20)
比较两个 std::stop_source 对象
(函数)
特化 std::swap 算法
(函数)

辅助标签

用于 stop_source 的标签,指示构造时不关联停止状态
(标签)

注释

为实现 std::jthread 的取消操作,应通过 get_stop_source() std::jthread 对象获取 stop_source 对象;或直接通过 request_stop() std::jthread 对象请求停止。这将使用与传入 std::jthread 调用函数参数(即在其线程上执行的函数)相同的关联停止状态。

对于其他用途,可以通过默认构造函数单独构造一个 stop_source ,这会创建新的停止状态。

功能测试 标准 功能
__cpp_lib_jthread 201911L (C++20) 停止令牌 可汇合线程

示例

#include <chrono>
#include <iostream>
#include <stop_token>
#include <thread>
using namespace std::chrono_literals;
void worker_fun(int id, std::stop_token stoken)
{ 
    for (int i = 10; i; --i)
    {
        std::this_thread::sleep_for(300ms);
        if (stoken.stop_requested())
        {
            std::printf("  worker%d is requested to stop\n", id);
            return;
        }
        std::printf("  worker%d goes back to sleep\n", id);
    }
}
int main()
{
    std::jthread threads[4];
    std::cout << std::boolalpha;
    auto print = [](const std::stop_source& source)
    {
        std::printf("stop_source stop_possible = %s, stop_requested = %s\n",
                    source.stop_possible() ? "true" : "false",
                    source.stop_requested() ? "true" : "false");
    };
    // 公共停止源
    std::stop_source stop_source;
    print(stop_source);
    // 创建工作线程
    for (int i = 0; i < 4; ++i)
        threads[i] = std::jthread(worker_fun, i + 1, stop_source.get_token());
    std::this_thread::sleep_for(500ms);
    std::puts("请求停止");
    stop_source.request_stop();
    print(stop_source);
    // 注意:jthread 的析构函数将调用 join,因此无需显式调用
}

可能的输出:

stop_source stop_possible = true, stop_requested = false
  worker2 goes back to sleep
  worker3 goes back to sleep
  worker1 goes back to sleep
  worker4 goes back to sleep
请求停止
stop_source stop_possible = true, stop_requested = true
  worker3 is requested to stop
  worker1 is requested to stop
  worker2 is requested to stop
  worker4 is requested to stop