C++ `std::latch` 与 `std::barrier`：C++20 新同步原语的实践

好的，各位观众老爷们，欢迎来到今天的C++20同步原语特别节目！今天我们要聊的是C++20带来的两位新朋友：std::latch 和 std::barrier。它们就像是同步界的“双子星”，功能相似，但应用场景却略有不同。

开场白：为什么我们需要新同步原语？

在C++11之后，我们已经有了std::mutex、std::condition_variable、std::atomic等同步工具。但这些工具在某些特定场景下使用起来比较繁琐，容易出错。比如，需要等待多个线程完成初始化，或者需要多个线程同步执行一个任务的不同阶段。

std::latch 和 std::barrier 的出现，就是为了简化这些场景下的同步操作，让我们的代码更简洁、更易读、更安全。

第一位嘉宾：std::latch——一次性倒计时器

std::latch，你可以把它想象成一个一次性的倒计时器。它有一个初始计数器，当计数器减到0时，所有等待在该latch上的线程都会被释放。一旦计数器归零，就不能再重置了。

1. std::latch 的基本用法

构造函数： std::latch latch(int count); 创建一个 latch 对象，初始计数器为 count。
count_down()： latch.count_down(); 将计数器减1。
wait()： latch.wait(); 阻塞当前线程，直到计数器变为0。
try_wait()： latch.try_wait(); 尝试减少计数器到0，如果不能立即减少，则返回false。
arrive_and_wait()： latch.arrive_and_wait(); 如果计数器不为0，则减少计数器，并阻塞线程直到计数器为0，否则不阻塞线程。这个操作是原子的。

2. std::latch 的应用场景：等待线程初始化

这是 std::latch 最常见的应用场景。假设我们需要启动多个线程来执行任务，但在所有线程都完成初始化之前，主线程需要等待。

#include <iostream>
#include <thread>
#include <latch>
#include <vector>

void worker_thread(int id, std::latch& start_latch) {
    std::cout << "线程 " << id << " 正在初始化...n";
    // 模拟初始化过程
    std::this_thread::sleep_for(std::chrono::milliseconds(500));
    std::cout << "线程 " << id << " 初始化完成n";
    start_latch.count_down(); // 线程初始化完成后，倒计时
}

int main() {
    const int num_threads = 5;
    std::latch start_latch(num_threads); // 初始化 latch，计数器为线程数量
    std::vector<std::thread> threads;

    for (int i = 0; i < num_threads; ++i) {
        threads.emplace_back(worker_thread, i, std::ref(start_latch));
    }

    std::cout << "等待所有线程初始化完成...n";
    start_latch.wait(); // 主线程等待，直到 latch 计数器变为 0
    std::cout << "所有线程初始化完成，主线程继续执行n";

    for (auto& thread : threads) {
        thread.join();
    }

    return 0;
}

在这个例子中，start_latch 的初始计数器为线程的数量。每个线程在完成初始化后，调用 count_down() 方法将计数器减1。主线程调用 wait() 方法等待，直到所有线程都完成初始化，start_latch 的计数器变为0，主线程才继续执行。

3. std::latch 的优点

简单易用： API 简单明了，容易理解和使用。
高效： 针对一次性同步场景进行了优化。
避免死锁： 使用 latch 比使用 mutex 和 condition_variable 更不容易出错，可以避免死锁。

第二位嘉宾：std::barrier——可重用的同步点

std::barrier，你可以把它想象成一个可重用的同步点。它也维护一个计数器，当指定数量的线程到达该同步点时，所有线程会被同时释放，并执行一个可选的完成函数。与latch不同的是，barrier可以重置，用于多次同步。

1. std::barrier 的基本用法

构造函数： std::barrier barrier(int parties); 创建一个 barrier 对象，parties 指定需要到达同步点的线程数量。
std::barrier barrier(int parties, std::function<void()> completion); 创建一个 barrier 对象，parties 指定需要到达同步点的线程数量, completion指定完成函数。
arrive_and_wait()： barrier.arrive_and_wait(); 线程到达同步点，并阻塞，直到所有线程都到达。
arrive()： barrier.arrive(); 线程到达同步点，并通知其他线程。
wait()： barrier.wait(); 线程等待直到所有线程到达同步点。
arrive_and_drop(): barrier.arrive_and_drop(); 线程到达同步点，并从参与者中移除。

2. std::barrier 的应用场景：多线程算法的阶段同步

在某些多线程算法中，需要将任务分解成多个阶段，每个阶段都需要所有线程同步完成。std::barrier 非常适合这种场景。

#include <iostream>
#include <thread>
#include <barrier>
#include <vector>

void worker_thread(int id, std::barrier& barrier, int num_phases) {
    for (int phase = 0; phase < num_phases; ++phase) {
        std::cout << "线程 " << id << " 开始执行第 " << phase + 1 << " 阶段n";
        // 模拟执行阶段任务
        std::this_thread::sleep_for(std::chrono::milliseconds(rand()%500));
        std::cout << "线程 " << id << " 第 " << phase + 1 << " 阶段执行完成，等待其他线程n";
        barrier.arrive_and_wait(); // 到达同步点，等待其他线程
        std::cout << "线程 " << id << " 继续执行第 " << phase + 1 << " 阶段之后的任务n";
    }
}

int main() {
    const int num_threads = 3;
    const int num_phases = 3;

    auto phase_completion = []() {
        std::cout << "所有线程完成一个阶段，执行完成函数！n";
    };

    std::barrier barrier(num_threads, phase_completion); // 初始化 barrier，指定线程数量和完成函数
    std::vector<std::thread> threads;

    for (int i = 0; i < num_threads; ++i) {
        threads.emplace_back(worker_thread, i, std::ref(barrier), num_phases);
    }

    for (auto& thread : threads) {
        thread.join();
    }

    return 0;
}

在这个例子中，barrier 的初始参与者数量为线程的数量。每个线程在完成一个阶段的任务后，调用 arrive_and_wait() 方法到达同步点并等待。当所有线程都到达同步点后，barrier 会自动重置，并执行完成函数（如果指定了）。然后，所有线程会被释放，继续执行下一个阶段的任务。

3. std::barrier 的优点

可重用： 可以用于多次同步，适用于多阶段任务。
支持完成函数： 可以在所有线程到达同步点后，执行一个额外的函数，方便进行一些全局性的操作。
更加灵活： 提供了 arrive() 和 wait() 方法，可以更灵活地控制同步过程。

std::latch vs std::barrier：选择困难症患者的福音

特性	`std::latch`	`std::barrier`
使用场景	一次性事件同步，例如等待线程初始化	多阶段同步，例如多线程算法的阶段同步
可重用性	不可重用，计数器归零后无法重置	可重用，每次同步后会自动重置
完成函数	不支持	支持，可以在所有线程到达同步点后执行一个额外的函数
主要方法	`count_down()`, `wait()`	`arrive_and_wait()`, `arrive()`, `wait()`
适用性	需要线程等待所有线程执行完成某个一次性任务。	需要线程在多个阶段进行同步，并且可以选择执行完成函数。
场景举例	等待多个线程初始化完成，然后主线程继续执行。	并行计算的多个阶段，每个阶段都需要所有线程同步完成。

总结：同步不再是难题

std::latch 和 std::barrier 是 C++20 引入的两个强大的同步原语，它们可以简化多线程编程中的同步操作，提高代码的可读性和安全性。latch 适用于一次性同步场景，而 barrier 适用于多阶段同步场景。

希望今天的讲解能够帮助大家更好地理解和使用这两个新的同步工具。记住，选择合适的工具，才能让你的多线程代码更加优雅、高效、稳定！

额外说明：

避免虚假唤醒： 虽然 latch 和 barrier 在设计上已经尽可能避免虚假唤醒，但在某些特殊情况下，仍然可能发生。因此，在编写多线程代码时，仍然需要注意处理虚假唤醒的情况。
性能考虑： 虽然 latch 和 barrier 提供了更高级别的同步抽象，但在某些对性能要求非常高的场景下，直接使用 atomic 操作可能仍然是更好的选择。
编译器支持： 请确保你的编译器支持 C++20 标准，才能使用 latch 和 barrier。

结束语：

感谢大家的收看，希望今天的节目对您有所帮助。记住，多线程编程虽然复杂，但只要掌握了正确的工具和方法，就能写出高效、稳定的多线程应用程序。下次再见！

发表回复 取消回复

发表回复取消回复