std::latch

< cpp‎ | thread
在标头 <latch> 定义
class latch;
 (C++20 起)

latch 是 std::ptrdiff_t 类型的向下计数器，它能用于同步线程。在创建时初始化计数器的值。

线程可能在 latch 上阻塞直至计数器减少到零。没有可能增加或重置计数器，这使得 latch 为单次使用的屏障。

同时调用 latch 的成员函数，除了析构函数，不引入数据竞争。

不同于 std::barrier ，参与线程能减少 std::latch 多于一次。

成员函数

 构造 latch
(公开成员函数)
析构 latch
(公开成员函数)
operator=
[被删除]
 latch 不可赋值
(公开成员函数)
以不阻塞的方式减少计数器
(公开成员函数)
测试内部计数器是否等于零
(公开成员函数)
阻塞直至计数器抵达零
(公开成员函数)
减少计数器并阻塞直至它抵达零
(公开成员函数)
常量
[静态]
 实现所支持的计数器最大值
(公开静态成员函数)

示例

#include<iostream>
#include<concepts>
#include<thread>
#include<vector>
#include<latch>
#include<mutex>
 
//sleep sort
template<std::integral T>
void sleep_sort(std::vector<T>& v){
        std::latch l{static_cast<std::ptrdiff_t>(v.size())};
        std::mutex mutex;
        std::vector<T>tmp;
        for(auto& i:v)
                std::thread([](int vv,std::mutex& mtx,std::vector<T>& vec,std::latch& lt){
                        std::this_thread::sleep_for(std::chrono::milliseconds(vv));
                        std::lock_guard guard{mtx};
                        vec.emplace_back(vv);
                        lt.count_down();
                },i,std::ref(mutex),std::ref(tmp),std::ref(l)).detach();
        l.wait();
        v=tmp;
}
 
int main(){
        std::vector v{400,200,300,100,500};
        sleep_sort(v);
        std::cout<<"sorted array:"<<std::endl;
        for(auto i:v)
                std::cout<<i<<' ';
        std::cout<<std::endl;
 
        return 0;
}

可能的输出：

100 200 300 400 500

参阅

(C++20)
 可复用的线程屏障
(类模板)