# 线程闩std::latch和线程卡std::barrier

# 线程闩std::latch

线程闩std::latchc++20中引入的类,是为了计数std::ptrdiff_t类型的变量。

std::latch中使用的计数器在创建时初始化,线程工作过程中逐渐减少变量的值,直到为零。

std::latch对象中的值不支持重置或修改。

#include <thread>
#include <latch>
#include <vector>
#include <future>
struct my_data
{
    int x;
    int y;
};

my_data make_data(int i){ return {i, i+1}; }
void do_more_stuff() {

}
void process_data(my_data &data, unsigned count) 
{

}

void foo(){
    unsigned const thread_count=10;
    std::experimental::latch done(thread_count);
    my_data data[thread_count];
    std::vector<std::future<void>> threads;
    for(unsigned i=0;i<thread_count;++i)
        threads.push_back(std::async(std::launch::async,[&,i]{ 
            data[i]=make_data(i);
            done.count_down();
            do_more_stuff(); 
        }));
    done.wait();
    process_data(data,thread_count);
}

int main(int argc, char **argv)
{
    foo();
}

上面的代码中,先使用std::experimental::latch设置计数的线程数,然后在std::async使用的函数,是lambda表达式,其参数除了i都是通过捕获的方法传递的引用。每个线程任务执行完,会调用.count_down();方法,使得值能够减少,直到为0done.wait();会阻塞进程,等待所有的线程执行结束,std::latch的值变为0为止。

# 线程卡std::barrier的使用

std::barrier是一个模板类。

线程卡的应用场景如下:

有一组线程在协同处理某些数据,各线程相互独立,分别处理数据,因此操作过程不必同步。但是,只有在全部线程都完成各自的处理后,才可以操作下一项数据或开始后续处理,这时就需要用到std::barrier线程卡。

线程卡的使用是为了同步一组线程。线程在完成自身的处理后,就运行到线程卡处,通过在线程卡对象上调用arrive_and_wait()等待同步组的其他线程。

#include <thread>
#include <vector>
#include <future>

#include <barrier>
#include <iostream>
#include <string>
#include <syncstream>

void test_barrier()
{
    const auto workers = {"zhangsan", "zhaosi", "wanger"};
    auto on_complete = []() noexcept {
        static auto phase = "...done\n"
        "Cleaning up...\n";
        std::cout << phase;
        phase = "...done\n";
    };

    std::barrier sync_point(std::ssize(workers), on_complete);
    auto work = [&](std::string name) {
        std::string product = "\t" + name " worked.\n";
        std::osyncstream(std::cout) << product;
        sync_point.arrive_and_wait();

        product = "\t" + name + " cleaned.\n";
        std::osyncstream(std::cout) << product;
        sync_point.arrive_and_wait();
    };

    std::cout << "Starting...\n";
    std::vector<std::jthread> threads
    threads.reserve(std::size(workers));
    for(auto const &worker : workers) {
        threads.emplace_back(work, worker);
    }
}

int main(int argc, char **argv)
{
    test_barrier();
    return 0;
}

上例中使用的std::jthread也是新的c++20的特性,相较于std::threadstd::jthread增加了一个方法stop_token,用以实现线程的可控终止,std::jthread 具有一个 std::stop_token,用于发送停止请求给线程的执行。std::stop_token 允许控制线程的终止,如果在线程内部正确处理,可以实现受控的终止。

std::syncstreamC++20 中用于同步输出流的新特性,可以帮助我们在多线程环境下安全地进行输出操作。

# 线程闩std::latch和线程卡std::barrier的区别

  • 线程闩的意义在于关闸拦截:一旦它进入了就绪状态,就始终保持不变。
  • 线程卡则不同,线程卡会释放等待的线程并且自我重置,因此它们可重复使用。
  • 线程卡只与一组固定的线程同步,若某线程不属于同步组,它就不会被阻拦,亦无须等待相关的线程卡变为就绪
  • std::latch 适用于一次性的同步需求,而 std::barrier 更适合多阶段任务的同步。从上面的例子中可以看到,std::barrier 可以被多次调用,直到控制所有线程多次都到达同步点。

# reference