C++20新特性：std::latch与std::barrier详解

std::latch用于一次性线程同步，如主线程等待多线程完成；std::barrier支持重复使用，适用于多阶段并行计算的周期性同步，两者均提升C++20并发编程的简洁性与安全性。

在C++20中，std::latch 和 std::barrier 是两个新增的线程同步工具，它们用于协调多个线程之间的执行时机。相比传统的互斥锁和条件变量，它们更轻量、语义更清晰，特别适合用于“等待一组线程完成”或“阶段性同步”的场景。

std::latch：一次性倒计时门闩

std::latch 是一个一次性使用的同步机制，它维护一个内部计数器，初始值由构造函数指定。多个线程可以调用 count_down() 来减少计数，而其他线程可以调用 wait() 或 arrive_and_wait() 来阻塞，直到计数归零。

关键特性：

• 只能使用一次，一旦计数归零，所有等待线程被释放，之后不能再重置。
• 常用于主线程等待多个工作线程完成任务的场景。
• 支持 try_wait() 和带超时的等待，增加灵活性。

示例：主线程启动5个线程，等待它们全部完成。

#include 
#include 
#include 
#include 

void worker(std::latch& latch) {
    std::cout << "线程 " << std::this_thread::get_id() 
              << " 完成工作\n";
    latch.count_down();
}

int main() {
    std::latch latch(5);
    std::vector threads;

    for (int i = 0; i < 5; ++i) {
        threads.emplace_back(worker, std::ref(latch));
    }

    latch.wait(); // 等待5个线程都调用 count_down()
    std::cout << "所有线程已完成。\n";

    for (auto& t : threads) t.join();
}

std::barrier：可重复使用的屏障

std::barrier 与 latch 类似，但它支持重复使用。每当累计有 N 个线程到达屏障点（调用 arrive_and_wait()），所有线程被释放，并自动重置状态，可用于下一轮同步。

适用场景：

• 多阶段并行计算，如迭代算法中的每轮同步。
• 需要周期性等待所有线程汇合的情况。
• 支持在最后一个到达的线程上执行“阶段完成”回调函数（通过构造时传入）。

示例：4个线程进行两轮并行任务，每轮结束后同步。

#include 
#include 
#include 

void stage_worker(int id, std::barrier<>& phase) {
    std::cout << "线程 " << id << " 完成第一阶段\n";
    phase.arrive_and_wait();

    std::cout << "线程 " << id << " 完成第二阶段\n";
    phase.arrive_and_wait();
}

int main() {
    std::barrier barrier(4); // 需要4个线程同步

    std::thread t1(stage_worker, 1, std::ref(barrier));
    std::thread t2(stage_worker, 2, std::ref(barrier));
    std::thread t3(stage_worker, 3, std::ref(barrier));
    std::thread t4(stage_worker, 4, std::ref(barrier));

    t1.join(); t2.join(); t3.join(); t4.join();
}

latch vs barrier：如何选择？

两者都用于线程汇合，但用途不同：

• 用 std::latch 当你只需要一次等待，比如启动后等待初始化完成，或任务结束前汇总结果。
• 用 std::barrier 当你需要多次同步，比如循环并行处理、分阶段计算等。
• latch 更简单，barrier 功能更强，但开销略高。

基本上就这些。这两个工具让C++20的并发编程更现代、简洁，减少了手写条件变量的复杂性和出错概率。合理使用它们，能显著提升代码可读性和线程安全。不复杂但容易忽略的是：它们都不支持动态调整参与线程数量，设计时需提前确定协作规模。