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

# 线程闩std::latch

线程闩std::latch是c++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();方法，使得值能够减少，直到为0，done.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::thread，std::jthread增加了一个方法stop_token，用以实现线程的可控终止，std::jthread 具有一个 std::stop_token，用于发送停止请求给线程的执行。std::stop_token 允许控制线程的终止，如果在线程内部正确处理，可以实现受控的终止。

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