各位编程爱好者、系统架构师，以及所有对高性能并发编程充满热情的同仁们，大家好！
今天，我们将深入探讨C++20标准库中引入的两个强大且优雅的同步原语：std::latch 和 std::barrier。在多线程编程中，高效地协调线程行为是实现高性能的关键。尤其是在复杂的阶段性计算任务中，如何确保所有线程在进入下一阶段前都完成了当前阶段的工作，是一个常见的挑战。C++20的这些新工具，正是为了解决此类问题而生，它们以其简洁的接口和高效的实现，极大地简化了多线程阶段同步的编程模型。
作为一名编程专家，我将带领大家从理论到实践，全面理解这两个原语的设计理念、使用场景、API细节，并通过丰富的代码示例，展示它们如何在实际项目中发挥作用。我们还将深入比较两者的异同，并探讨它们在性能和可维护性方面的优势。
1. 多线程同步的挑战与传统方法回顾
在进入C++20的新世界之前，我们先快速回顾一下多线程同步的常见问题和传统解决方案。
多线程编程的本质在于，多个执行流（线程）共享相同的内存空间，这带来了数据竞争（Race Condition）、死锁（Deadlock）、活锁（Livelock）等一系列复杂问题。为了解决这些问题，我们通常依赖于各种同步原语：
- 互斥量（
std::mutex）：用于保护共享数据，确保在任何时刻只有一个线程可以访问临界区。 - 条件变量（
std::condition_variable）：与互斥量配合使用，允许线程等待某个条件为真，或通知其他线程条件已满足。 - 原子操作（
std::atomic）：提供无锁的、原子性的操作，适用于简单的计数器、标志位等。 - 信号量（
std::counting_semaphorein C++20）：控制对有限资源的访问数量。
然而，对于特定的同步模式——阶段同步（Phase Synchronization），即一组线程需要全部到达某个共同点，才能一起继续执行下一个阶段的工作，传统的互斥量和条件变量虽然能够实现，但通常会导致代码复杂、容易出错，并且可能效率不高。
考虑一个场景：我们有一个数据处理管道，分为三个阶段：
- 数据加载：多个线程并行加载不同部分的数据。
- 数据处理：所有数据加载完成后，多个线程并行处理这些数据。
- 结果聚合：所有数据处理完成后，一个或多个线程聚合最终结果。
在这种情况下，我们需要在阶段1和阶段2之间、阶段2和阶段3之间设置同步点，以确保所有线程都完成了前一阶段的任务才能进入下一阶段。如果使用 std::mutex 和 std::condition_variable 来实现，通常需要一个计数器来跟踪已到达的线程数量，并在计数器达到预期值时通过 notify_all 唤醒所有等待线程。这不仅代码量大，而且每次循环都需要重置计数器，管理起来比较繁琐。
C++20的 std::latch 和 std::barrier 正是为了解决这种特定类型的同步需求而设计的。
2. std::latch：一次性倒计时门闩
std::latch（门闩）是一个简单但非常有效的同步原语，它表示一个一次性的计数器，一旦计数归零，它就会永久打开，允许所有等待的线程通过。它的主要特点是：不可重用。
2.1 设计理念与使用场景
std::latch 的核心思想是“等待所有人都准备好”。它适用于一次性的初始化任务、程序启动、或者在某些关键操作开始前等待所有参与者就绪的场景。例如：
- 主线程创建多个工作线程，并等待所有工作线程完成初始化配置。
- 一组工作线程等待一个共享资源被完全初始化。
- 在一个并行算法中，所有任务都必须在某个特定点完成，才能进行下一步的聚合操作。
2.2 std::latch 的核心API
| 方法名 | 描述 |
|---|---|
latch(ptrdiff_t expected) |
构造函数，初始化一个计数器，expected 表示需要等待的线程数量（或需要倒计时的次数）。 |
void count_down(ptrdiff_t update = 1) |
将内部计数器减去 update。如果计数器归零，则释放所有等待的线程。此操作不阻塞。 |
void wait() const |
阻塞当前线程，直到内部计数器归零。 |
void arrive_and_wait(ptrdiff_t update = 1) |
这是一个原子操作，首先调用 count_down(update)，然后调用 wait()。即，当前线程将自己计入倒计时，然后等待。 |
bool try_wait() const |
非阻塞地检查计数器是否已归零。 |
2.3 std::latch 代码示例：多线程启动同步
让我们通过一个简单的例子来理解 std::latch 的用法。假设我们有多个工作线程，它们需要等待主线程发出“开始工作”的信号，或者等待所有线程都准备就绪才能开始。
#include <iostream>
#include <thread>
#include <vector>
#include <numeric>
#include <latch> // C++20 latch header
#include <chrono>
// 模拟工作线程
void worker_function(int id, std::latch& start_latch, std::latch& finish_latch) {
std::cout << "Worker " << id << ": Initializing..." << std::endl;
std::this_thread::sleep_for(std::chrono::milliseconds(100 + id * 50)); // 模拟初始化工作
std::cout << "Worker " << id << ": Ready to start, waiting for signal." << std::endl;
start_latch.arrive_and_wait(); // 线程到达并等待开始信号
std::cout << "Worker " << id << ": Starting work!" << std::endl;
std::this_thread::sleep_for(std::chrono::milliseconds(500 + id * 100)); // 模拟实际工作
std::cout << "Worker " << id << ": Work finished, counting down." << std::endl;
finish_latch.count_down(); // 工作完成，倒计时
}
int main() {
const int num_workers = 5;
// 创建一个latch，用于等待所有工作线程准备就绪
// 初始计数为 num_workers，每个工作线程调用 arrive_and_wait() 会减少计数
std::latch start_latch(num_workers);
// 创建另一个latch，用于等待所有工作线程完成任务
// 初始计数为 num_workers，每个工作线程调用 count_down() 会减少计数
std::latch finish_latch(num_workers);
std::vector<std::thread> workers;
for (int i = 0; i < num_workers; ++i) {
workers.emplace_back(worker_function, i, std::ref(start_latch), std::ref(finish_latch));
}
std::cout << "Main thread: All workers launched, waiting for them to be ready..." << std::endl;
// 主线程在此等待所有工作线程都调用了 start_latch.arrive_and_wait()
// 换句话说，等待 start_latch 的计数归零
start_latch.wait();
std::cout << "Main thread: All workers are ready! Signaling them to start." << std::endl;
// 注意：start_latch.wait() 已经阻塞直到计数归零，一旦通过，所有等待的线程都会被释放。
// 这里不需要额外的 count_down，因为工作线程已经通过 arrive_and_wait 减少了计数。
std::cout << "Main thread: Workers are busy, waiting for them to finish..." << std::endl;
// 主线程等待所有工作线程完成任务
finish_latch.wait();
std::cout << "Main thread: All workers finished their tasks. Joining threads." << std::endl;
for (auto& worker : workers) {
worker.join();
}
std::cout << "Main thread: All workers joined. Program finished." << std::endl;
return 0;
}运行结果（示例）：
Main thread: All workers launched, waiting for them to be ready...
Worker 0: Initializing...
Worker 1: Initializing...
Worker 2: Initializing...
Worker 3: Initializing...
Worker 4: Initializing...
Worker 0: Ready to start, waiting for signal.
Worker 1: Ready to start, waiting for signal.
Worker 2: Ready to start, waiting for signal.
Worker 3: Ready to start, waiting for signal.
Worker 4: Ready to start, waiting for signal.
Main thread: All workers are ready! Signaling them to start.
Worker 0: Starting work!
Worker 1: Starting work!
Worker 2: Starting work!
Worker 3: Starting work!
Worker 4: Starting work!
Main thread: Workers are busy, waiting for them to finish...
Worker 0: Work finished, counting down.
Worker 1: Work finished, counting down.
Worker 2: Work finished, counting down.
Worker 3: Work finished, counting down.
Worker 4: Work finished, counting down.
Main thread: All workers finished their tasks. Joining threads.
Main thread: All workers joined. Program finished.从输出中可以看出，所有工作线程都在 start_latch.wait() 处同步，只有当所有线程都报告“准备就绪”后，它们才一起开始工作。同样，主线程在 finish_latch.wait() 处等待所有工作线程完成任务。std::latch 简洁地实现了这种“一次性”的等待-通知模式。
3. std::barrier：可重用的多阶段同步屏障
std::barrier（屏障）是比 std::latch 更强大的同步原语，它允许多个线程在多个阶段进行同步。与 std::latch 的一次性使用不同，std::barrier 可以重复使用，使其非常适合迭代算法、并行计算的流水线阶段等场景。
3.1 设计理念与使用场景
std::barrier 的核心理念是“所有人都到达这里，我们才能一起进入下一阶段”。每当所有参与者都到达屏障点时，屏障就会“打开”，允许所有等待的线程继续执行。然后，屏障会自动重置，为下一轮同步做好准备。
std::barrier 最强大的特性之一是它的完成函数（completion function）。当屏障计数归零时（即所有线程都已到达），在释放等待线程之前，会在一个任意线程的上下文中执行这个完成函数。这提供了一个在阶段之间执行协调任务的极佳机会，例如：
- 聚合当前阶段的结果。
- 准备下一阶段的数据。
- 检查终止条件。
- 仅由一个线程执行的日志记录或状态更新。
适用于 std::barrier 的场景包括：
- 并行迭代算法：如Jacobi迭代、Gauss-Seidel迭代，每一轮迭代都需要所有线程完成计算才能开始下一轮。
- 游戏引擎的更新循环：渲染线程、物理线程、AI线程等需要在每个帧的开始和结束时同步。
- 多阶段数据处理流水线：每个阶段都涉及多个线程并行处理数据，并且在进入下一阶段前需要所有线程都完成当前阶段的工作。
3.2 std::barrier 的核心API
| 方法名 | 描述 |
|---|---|
barrier(ptrdiff_t initial_parties, CompletionFunction f = []{}) |
构造函数，initial_parties 表示初始参与屏障的线程数量。f 是一个可选的完成函数，当所有线程到达屏障时，会在一个任意线程的上下文中执行。 |
barrier_token arrive(ptrdiff_t update = 1) |
当前线程到达屏障，并将计数器减去 update。此操作不阻塞。返回一个 barrier_token，可用于 wait。 |
void wait(barrier_token&& token) |
阻塞当前线程，直到屏障的计数归零，并且当前线程被释放。token 是由 arrive 返回的。 |
void arrive_and_wait() |
一个原子操作，当前线程到达屏障（计数减1）并阻塞，直到所有线程都到达。当计数归零时，屏障打开，所有等待线程被释放，并自动重置以供下一阶段使用。 |
void arrive_and_drop() |
当前线程到达屏障（计数减1），并且此线程将不再参与后续的屏障同步。当计数归零时，屏障打开，所有等待线程被释放。屏障重置时，initial_parties 会减1。适用于某些线程提前完成工作并退出屏障的场景。 |
ptrdiff_t current_parties_expected() const noexcept |
获取当前屏障期望的线程数量。 |
ptrdiff_t current_parties_on_completion() const noexcept |
获取在当前屏障周期内，当所有线程到达时，实际有多少线程在等待（不包括那些只调用 arrive() 但不等待的线程）。 |
3.3 std::barrier 代码示例：多阶段并行数据处理
我们将使用 std::barrier 来模拟一个多阶段的并行数据处理流程。每个工作线程都处理一部分数据，并在每个阶段结束后同步。主线程也会参与屏障，或者通过完成函数来协调。
#include <iostream>
#include <thread>
#include <vector>
#include <numeric>
#include <barrier> // C++20 barrier header
#include <chrono>
#include <random>
// 共享数据，每个线程处理一部分
std::vector<int> shared_data;
const int DATA_SIZE = 1000;
const int NUM_STAGES = 3;
// 屏障的完成函数
// 它会在每个阶段所有线程到达屏障时，在一个任意线程的上下文中被调用
void barrier_completion_function() {
static int current_stage = 0;
std::cout << "--- Barrier Completion Function: All threads finished stage " << current_stage << " ---" << std::endl;
// 可以在这里进行一些阶段间的聚合、检查或准备工作
// 例如，检查数据是否一致，或者准备下一阶段的输入
if (current_stage < NUM_STAGES - 1) {
std::cout << "--- Preparing for next stage (" << current_stage + 1 << ") ---" << std::endl;
} else {
std::cout << "--- All stages completed ---" << std::endl;
}
current_stage++;
}
// 模拟工作线程
void worker_function(int id, int num_workers, std::barrier<decltype(&barrier_completion_function)>& task_barrier) {
// 每个线程处理数据的一部分
int start_idx = (DATA_SIZE / num_workers) * id;
int end_idx = (id == num_workers - 1) ? DATA_SIZE : (DATA_SIZE / num_workers) * (id + 1);
std::cout << "Worker " << id << ": Initializing and preparing to process data from index "
<< start_idx << " to " << end_idx - 1 << std::endl;
for (int stage = 0; stage < NUM_STAGES; ++stage) {
std::cout << "Worker " << id << ": Starting stage " << stage << std::endl;
// 模拟数据处理
for (int i = start_idx; i < end_idx; ++i) {
shared_data[i] += (id + 1) * (stage + 1); // 简单修改数据
// 模拟一些计算延迟
if (i % 100 == 0) {
std::this_thread::sleep_for(std::chrono::microseconds(10));
}
}
std::this_thread::sleep_for(std::chrono::milliseconds(50 + id * 10)); // 模拟阶段性工作
std::cout << "Worker " << id << ": Finished stage " << stage << ", waiting at barrier." << std::endl;
// 线程到达屏障并等待其他线程
// completion_function 将在所有线程到达后执行
task_barrier.arrive_and_wait();
std::cout << "Worker " << id << ": Passed barrier for stage " << stage << ", proceeding to next stage." << std::endl;
}
std::cout << "Worker " << id << ": All stages completed." << std::endl;
}
int main() {
const int num_workers = 4;
// 初始化共享数据
shared_data.resize(DATA_SIZE);
std::iota(shared_data.begin(), shared_data.end(), 0); // 填充 0, 1, 2...
// 创建屏障
// initial_parties 包含所有工作线程
// 传递完成函数 barrier_completion_function 的指针
std::barrier<decltype(&barrier_completion_function)> task_barrier(num_workers, &barrier_completion_function);
std::vector<std::thread> workers;
for (int i = 0; i < num_workers; ++i) {
workers.emplace_back(worker_function, i, num_workers, std::ref(task_barrier));
}
std::cout << "Main thread: All workers launched for multi-stage processing." << std::endl;
// 主线程不需要参与屏障，因为它不直接处理数据，
// 而是通过完成函数间接监控和协调。
// 如果主线程也需要参与每个阶段的同步，它可以也调用 arrive_and_wait()。
// 在这个例子中，主线程只负责启动和等待工作线程完成。
for (auto& worker : workers) {
worker.join();
}
std::cout << "Main thread: All workers joined. Final shared_data sample: " << std::endl;
for (int i = 0; i < 10; ++i) {
std::cout << shared_data[i] << " ";
}
std::cout << "..." << std::endl;
std::cout << "Main thread: Program finished." << std::endl;
return 0;
}运行结果（示例，输出顺序可能因调度而异）：
Main thread: All workers launched for multi-stage processing.
Worker 0: Initializing and preparing to process data from index 0 to 249
Worker 1: Initializing and preparing to process data from index 250 to 499
Worker 2: Initializing and preparing to process data from index 500 to 749
Worker 3: Initializing and preparing to process data from index 750 to 999
Worker 0: Starting stage 0
Worker 1: Starting stage 0
Worker 2: Starting stage 0
Worker 3: Starting stage 0
Worker 0: Finished stage 0, waiting at barrier.
Worker 1: Finished stage 0, waiting at barrier.
Worker 2: Finished stage 0, waiting at barrier.
Worker 3: Finished stage 0, waiting at barrier.
--- Barrier Completion Function: All threads finished stage 0 ---
--- Preparing for next stage (1) ---
Worker 0: Passed barrier for stage 0, proceeding to next stage.
Worker 1: Passed barrier for stage 0, proceeding to next stage.
Worker 2: Passed barrier for stage 0, proceeding to next stage.
Worker 3: Passed barrier for stage 0, proceeding to next stage.
Worker 0: Starting stage 1
Worker 1: Starting stage 1
Worker 2: Starting stage 1
Worker 3: Starting stage 1
Worker 0: Finished stage 1, waiting at barrier.
Worker 1: Finished stage 1, waiting at barrier.
Worker 2: Finished stage 1, waiting at barrier.
Worker 3: Finished stage 1, waiting at barrier.
--- Barrier Completion Function: All threads finished stage 1 ---
--- Preparing for next stage (2) ---
Worker 0: Passed barrier for stage 1, proceeding to next stage.
Worker 1: Passed barrier for stage 1, proceeding to next stage.
Worker 2: Passed barrier for stage 1, proceeding to next stage.
Worker 3: Passed barrier for stage 1, proceeding to next stage.
Worker 0: Starting stage 2
Worker 1: Starting stage 2
Worker 2: Starting stage 2
Worker 3: Starting stage 2
Worker 0: Finished stage 2, waiting at barrier.
Worker 1: Finished stage 2, waiting at barrier.
Worker 2: Finished stage 2, waiting at barrier.
Worker 3: Finished stage 2, waiting at barrier.
--- Barrier Completion Function: All threads finished stage 2 ---
--- All stages completed ---
Worker 0: Passed barrier for stage 2, proceeding to next stage.
Worker 1: Passed barrier for stage 2, proceeding to next stage.
Worker 2: Passed barrier for stage 2, proceeding to next stage.
Worker 3: Passed barrier for stage 2, proceeding to next stage.
Worker 0: All stages completed.
Worker 1: All stages completed.
Worker 2: All stages completed.
Worker 3: All stages completed.
Main thread: All workers joined. Final shared_data sample:
30 31 32 33 34 35 36 37 38 39 ...
Main thread: Program finished.这个例子清晰地展示了 std::barrier 如何在多个阶段中同步线程。每次所有工作线程都到达屏障时，barrier_completion_function 都会被执行一次，然后所有线程被释放，进入下一个阶段。
3.4 arrive_and_drop() 的使用
arrive_and_drop() 是 std::barrier 的一个特殊成员函数，它允许一个线程在完成当前阶段的工作后退出屏障，不再参与后续阶段的同步。这对于某些线程可能比其他线程更早完成所有工作，或者在某个阶段后就不再需要参与协调的场景非常有用。
当一个线程调用 arrive_and_drop() 时，它会减少当前屏障的计数，并且从后续屏障周期的 initial_parties 中移除自身。
#include <iostream>
#include <thread>
#include <vector>
#include <numeric>
#include <barrier>
#include <chrono>
void drop_completion_function() {
static int phase = 0;
std::cout << ">>> Completion: Phase " << phase++ << " completed. Current parties expected: "
<< std::this_thread::get_id() << std::endl; // Completion function runs on one of the threads
}
void worker_with_drop(int id, int num_stages, std::barrier<decltype(&drop_completion_function)>& b) {
for (int stage = 0; stage < num_stages; ++stage) {
std::cout << "Worker " << id << " (stage " << stage << "): Doing work." << std::endl;
std::this_thread::sleep_for(std::chrono::milliseconds(100));
if (id == 0 && stage == 1) { // 假设 worker 0 在第二阶段后退出
std::cout << "Worker " << id << " (stage " << stage << "): Finishing early, dropping out." << std::endl;
b.arrive_and_drop(); // 线程0完成当前阶段并退出屏障
return; // 线程0不再参与后续阶段
} else {
std::cout << "Worker " << id << " (stage " << stage << "): Arriving and waiting." << std::endl;
b.arrive_and_wait();
}
}
std::cout << "Worker " << id << ": All stages completed." << std::endl;
}
int main() {
const int num_initial_workers = 3;
const int total_stages = 4;
std::barrier<decltype(&drop_completion_function)> my_barrier(num_initial_workers, &drop_completion_function);
std::vector<std::thread> workers;
for (int i = 0; i < num_initial_workers; ++i) {
workers.emplace_back(worker_with_drop, i, total_stages, std::ref(my_barrier));
}
for (auto& w : workers) {
w.join();
}
std::cout << "Main thread: All workers joined." << std::endl;
return 0;
}运行结果（示例）：
Worker 0 (stage 0): Doing work.
Worker 1 (stage 0): Doing work.
Worker 2 (stage 0): Doing work.
Worker 0 (stage 0): Arriving and waiting.
Worker 1 (stage 0): Arriving and waiting.
Worker 2 (stage 0): Arriving and waiting.
>>> Completion: Phase 0 completed. Current parties expected: 0x70000bd93000
Worker 0 (stage 0): Passed barrier for stage 0, proceeding to next stage.
Worker 1 (stage 0): Passed barrier for stage 0, proceeding to next stage.
Worker 2 (stage 0): Passed barrier for stage 0, proceeding to next stage.
Worker 0 (stage 1): Doing work.
Worker 1 (stage 1): Doing work.
Worker 2 (stage 1): Doing work.
Worker 0 (stage 1): Finishing early, dropping out.
Worker 1 (stage 1): Arriving and waiting.
Worker 2 (stage 1): Arriving and waiting.
>>> Completion: Phase 1 completed. Current parties expected: 0x70000bd10000
Worker 1 (stage 1): Passed barrier for stage 1, proceeding to next stage.
Worker 2 (stage 1): Passed barrier for stage 1, proceeding to next stage.
Worker 0: All stages completed.
Worker 1 (stage 2): Doing work.
Worker 2 (stage 2): Doing work.
Worker 1 (stage 2): Arriving and waiting.
Worker 2 (stage 2): Arriving and waiting.
>>> Completion: Phase 2 completed. Current parties expected: 0x70000bd10000
Worker 1 (stage 2): Passed barrier for stage 2, proceeding to next stage.
Worker 2 (stage 2): Passed barrier for stage 2, proceeding to next stage.
Worker 1 (stage 3): Doing work.
Worker 2 (stage 3): Doing work.
Worker 1 (stage 3): Arriving and waiting.
Worker 2 (stage 3): Arriving and waiting.
>>> Completion: Phase 3 completed. Current parties expected: 0x70000bd10000
Worker 1 (stage 3): Passed barrier for stage 3, proceeding to next stage.
Worker 2 (stage 3): Passed barrier for stage 3, proceeding to next stage.
Worker 1: All stages completed.
Worker 2: All stages completed.
Main thread: All workers joined.可以看到，在第二阶段结束后，Worker 0 调用 arrive_and_drop() 并退出。从第三阶段开始，屏障只需要等待 Worker 1 和 Worker 2 两个线程。my_barrier 的内部 initial_parties 计数会自动从 3 变为 2。
4. std::latch 与 std::barrier 的比较
理解了 std::latch 和 std::barrier 各自的特性后，我们可以总结它们的异同，以便在实际应用中做出正确的选择。
4.1 核心区别概览
| 特性 | std::latch |
std::barrier |
|---|---|---|
| 重用性 | 一次性（One-shot），计数归零后不可重用 | 可重用（Reusable），每轮同步后自动重置 |
| 用途 | 初始启动、等待所有前置条件就绪 | 多阶段迭代、循环同步，需要重复等待所有参与者才能进入下一阶段 |
| 完成函数 | 无 | 有，在每轮同步完成时在一个任意线程上下文中执行 |
| 线程退出 | 不支持显式减少参与者数量（只能在构造时指定） | 支持 arrive_and_drop()，动态减少后续参与者数量 |
| 复杂性 | 简单 | 相对复杂，但功能更强大 |
| 典型场景 | 程序启动、资源初始化、一次性任务完成等待 | 并行算法迭代、游戏循环、多阶段数据处理流水线 |
4.2 选择指南
- 如果你的同步需求是一次性的：即等待所有线程完成某个初始化或一次性任务后，就可以继续，且不需要在后续阶段再次同步这些线程，那么
std::latch是最简洁、最有效的选择。它的开销最小，接口最简单。 - 如果你的同步需求是多阶段的、可重复的：即线程需要在多个连续的计算阶段之间同步，并且在每个阶段结束后都需要等待所有参与者，那么
std::barrier是理想的选择。它的自动重置机制和完成函数极大地简化了这类复杂场景的编程。 - 如果需要动态调整参与同步的线程数量：当某些线程在完成部分工作后就不再需要参与后续同步时，
std::barrier的arrive_and_drop()功能提供了优雅的解决方案。
5. 性能考量与最佳实践
C++20 的同步原语在设计上考虑了性能。它们通常基于高效的原子操作和操作系统级别的等待机制实现，旨在减少不必要的上下文切换和锁竞争。
5.1 性能优化
- 避免过度同步：只在确实需要协调线程执行流时才使用同步原语。不必要的同步会引入开销，降低并行度。
- 减少锁竞争：尽管
std::latch和std::barrier内部可能使用锁或原子操作，但它们的设计目标是减少用户代码中手动管理锁的复杂性和潜在错误。 - 理解原子操作开销：在多核处理器上，原子操作（尤其是在不同CPU核心之间同步时）会涉及缓存同步和内存屏障，这可能比简单的内存访问更昂贵。然而，与手动实现的条件变量相比，标准库的实现通常经过高度优化。
- 完成函数的设计：
std::barrier的完成函数会在一个任意线程的上下文中执行。这意味着它应该是一个快速、无阻塞的操作，因为它会阻塞所有等待的线程。如果完成函数执行时间过长，会成为性能瓶颈。
5.2 错误处理与安全性
std::latch和std::barrier的操作不会抛出异常。- 死锁风险：虽然这些原语本身不太容易引起死锁，但在与自定义锁或其他同步原语混合使用时仍需小心。例如，如果在完成函数内部尝试获取一个已经被其他等待线程持有的锁，可能会导致死锁。
- 线程数量管理：在构造
std::latch和std::barrier时，正确指定expected或initial_parties的数量至关重要。如果指定的数量不正确，可能导致线程永远等待或提前释放。 arrive_and_drop()的谨慎使用：使用arrive_and_drop()意味着后续阶段的同步参与者数量会减少。如果其他线程没有意识到这个变化，可能会导致逻辑错误。
5.3 与其他同步原语的结合
std::latch 和 std::barrier 通常用于阶段同步，但它们可以与其他同步原语结合使用，以构建更复杂的并发模型。例如：
- 与
std::mutex结合：在屏障的完成函数中，可能需要访问并修改共享数据。这时，就需要std::mutex来保护这些共享数据。 - 与
std::condition_variable结合：尽管std::barrier已经是一个强大的阶段同步工具，但如果需要在阶段内部或阶段之间实现更复杂的条件等待，std::condition_variable仍然是不可或缺的。
6. 手动实现屏障与门闩的复杂性（以凸显C++20的价值）
为了更好地理解 std::latch 和 std::barrier 的价值，我们简要看一下在C++20之前，如何使用 std::mutex 和 std::condition_variable 来实现类似的功能。这会揭示出手动实现所需的复杂性和潜在的错误。
6.1 手动实现一个简单的Latch
一个简单的Latch，其功能是等待N个线程完成某个动作：
#include <mutex>
#include <condition_variable>
#include <atomic>
class ManualLatch {
public:
explicit ManualLatch(std::ptrdiff_t count) : count_(count) {}
void arrive_and_wait() {
std::unique_lock<std::mutex> lock(mtx_);
// 减少计数
if (--count_ == 0) {
// 如果计数归零，通知所有等待线程
cv_.notify_all();
} else {
// 否则，等待
cv_.wait(lock, [this]{ return count_ == 0; });
}
}
private:
std::mutex mtx_;
std::condition_variable cv_;
std::ptrdiff_t count_;
};
// ... 使用方式类似 std::latch这个手动实现的Latch功能相对简单，但已经需要小心处理互斥量和条件变量的正确使用。
6.2 手动实现一个简单的Barrier
实现一个可重用的Barrier则更加复杂，因为它需要处理“代（generation）”的概念，确保每个线程等待的是当前阶段的屏障，而不是之前或之后的阶段。
#include <mutex>
#include <condition_variable>
#include <atomic>
#include <functional>
class ManualBarrier {
public:
explicit ManualBarrier(std::ptrdiff_t initial_parties, std::function<void()> completion_func = nullptr)
: initial_parties_(initial_parties),
parties_left_(initial_parties),
generation_(0),
completion_func_(std::move(completion_func)) {
if (initial_parties_ <= 0) {
throw std::invalid_argument("initial_parties must be positive");
}
}
void arrive_and_wait() {
std::unique_lock<std::mutex> lock(mtx_);
std::ptrdiff_t current_generation = generation_; // 记录当前线程所属的屏障代
if (--parties_left_ == 0) {
// 所有线程都已到达
if (completion_func_) {
// 执行完成函数
// 注意：这里是在持有锁的情况下执行，如果完成函数耗时，会阻塞其他线程
// 更好的做法是在释放锁后，在一个线程中异步执行
completion_func_();
}
// 重置屏障状态，进入下一代
parties_left_ = initial_parties_;
generation_++;
cv_.notify_all(); // 唤醒所有等待的线程
} else {
// 还有线程未到达，当前线程等待
cv_.wait(lock, [this, current_generation]{
return current_generation != generation_; // 等待代号发生变化
});
}
}
private:
std::mutex mtx_;
std::condition_variable cv_;
std::ptrdiff_t initial_parties_; // 初始参与者数量
std::ptrdiff_t parties_left_; // 剩余未到达的参与者数量
std::ptrdiff_t generation_; // 屏障的“代”或“周期”
std::function<void()> completion_func_; // 完成函数
};
// ... 使用方式类似 std::barrier这个手动实现的Barrier，其复杂性明显高于Latch。它需要：
- 计数器管理：跟踪已到达的线程和总的线程数。
- 重置机制：在每个阶段结束后，需要将计数器重置回初始值。
- 代（Generation）管理：这是最关键的部分，用来区分不同阶段的同步。线程必须等待屏障从当前“代”切换到下一“代”，才能避免唤醒已经完成前一阶段的线程，或者被错误地唤醒。
- 完成函数调用：在计数归零时执行特定逻辑。
- 死锁和性能：手动实现很难保证高效和无死锁，例如在完成函数中持有锁可能导致性能问题。
相比之下，C++20 的 std::latch 和 std::barrier 将这些复杂性封装在标准库的内部，提供了简洁、安全、高效且经过良好测试的API。这使得开发者能够专注于业务逻辑，而不是底层复杂的同步机制。
7. 结语
C++20 引入的 std::latch 和 std::barrier 极大地提升了C++在并发编程领域的表达能力和效率。它们为多线程应用程序中的阶段同步提供了现代、简洁且高效的解决方案。理解并恰当使用这两个原语，能够帮助我们编写出更健壮、更易于维护、性能更优的多线程代码。
通过今天的探讨，希望大家对 std::latch 的一次性倒计时功能和 std::barrier 的多阶段可重用同步能力有了深入的理解。在未来的C++并发编程实践中，我鼓励大家积极采纳这些新特性，它们无疑将成为您工具箱中不可或缺的利器。