std::barrier 同步原语
什么是 std::barrier
std::barrier 是 C++20 引入的可重用同步原语,定义在 <barrier> 头文件中。与一次性的 std::latch 不同,barrier 可以反复使用——每轮(phase)所有线程到达后,计数器自动重置,进入下一轮。barrier 还支持在每轮结束时执行一个完成回调函数。
cpp
#include <barrier>
// 3 个线程参与同步,每轮结束时打印提示
std::barrier sync_point(3, []() noexcept {
std::cout << "--- 所有线程完成一轮 ---" << std::endl;
});barrier 的成员函数
| 函数 | 说明 |
|---|---|
barrier(n, f) | 构造,n 为参与线程数,f 为每轮完成回调 |
arrive(n=1) | 到达并递减计数器,返回 arrival_token |
wait(token) | 等待当前轮结束 |
arrive_and_wait() | 等价于 wait(arrive()) |
arrive_and_drop() | 到达并永久减少参与线程数 |
max() | 静态函数,返回支持的最大参与线程数 |
基本示例
cpp
#include <iostream>
#include <thread>
#include <barrier>
#include <vector>
#include <mutex>
#include <string>
#include <chrono>
#include <functional>
std::mutex cout_mutex;
void safe_print(const std::string& msg) {
std::lock_guard<std::mutex> lock(cout_mutex);
std::cout << msg << std::endl;
}
// ============================
// 示例1:基本的多轮同步
// ============================
void basic_demo() {
constexpr int num_threads = 3;
constexpr int num_rounds = 3;
// 每轮结束时执行的回调
auto on_phase_complete = []() noexcept {
safe_print(" >>> 所有线程完成一轮 <<<");
};
std::barrier sync_point(num_threads, on_phase_complete);
std::vector<std::jthread> threads;
for (int i = 0; i < num_threads; i++) {
threads.emplace_back([&sync_point, i, num_rounds] {
for (int round = 0; round < num_rounds; round++) {
// 模拟工作
std::this_thread::sleep_for(
std::chrono::milliseconds(20 * (i + 1)));
safe_print(" 线程 " + std::to_string(i)
+ " 完成第 " + std::to_string(round + 1) + " 轮");
// 到达并等待所有线程
sync_point.arrive_and_wait();
}
});
}
}
// ============================
// 示例2:分阶段数据处理
// ============================
void pipeline_demo() {
constexpr int num_threads = 4;
std::vector<int> data(num_threads, 0);
int phase_counter = 0;
auto on_complete = [&]() noexcept {
phase_counter++;
// 在每轮完成后汇总(只有最后到达的线程执行这个回调)
int sum = 0;
for (int v : data) sum += v;
safe_print(" 阶段 " + std::to_string(phase_counter)
+ " 完成,数据总和: " + std::to_string(sum));
};
std::barrier sync(num_threads, on_complete);
std::vector<std::jthread> threads;
for (int i = 0; i < num_threads; i++) {
threads.emplace_back([&sync, &data, i] {
// 阶段1:初始化数据
data[i] = i + 1;
sync.arrive_and_wait();
// 阶段2:数据翻倍
data[i] *= 2;
sync.arrive_and_wait();
// 阶段3:数据加10
data[i] += 10;
sync.arrive_and_wait();
});
}
}
// ============================
// 示例3:arrive 和 wait 分离
// ============================
void separate_arrive_wait_demo() {
constexpr int num_threads = 3;
std::barrier sync(num_threads);
std::vector<std::jthread> threads;
for (int i = 0; i < num_threads; i++) {
threads.emplace_back([&sync, i] {
safe_print(" 线程 " + std::to_string(i) + " 开始工作");
// arrive() 返回 arrival_token,不阻塞
auto token = sync.arrive();
// 到达后可以做一些不依赖其他线程的工作
safe_print(" 线程 " + std::to_string(i) + " 做独立工作");
// 需要同步时才 wait
sync.wait(std::move(token));
safe_print(" 线程 " + std::to_string(i) + " 同步完成");
});
}
}
// ============================
// 示例4:arrive_and_drop——线程退出
// ============================
void drop_demo() {
constexpr int num_threads = 4;
constexpr int num_rounds = 3;
int round_count = 0;
auto on_complete = [&]() noexcept {
round_count++;
safe_print(" >>> 第 " + std::to_string(round_count) + " 轮完成 <<<");
};
std::barrier sync(num_threads, on_complete);
std::vector<std::jthread> threads;
for (int i = 0; i < num_threads; i++) {
threads.emplace_back([&sync, i, num_rounds] {
for (int round = 0; round < num_rounds; round++) {
safe_print(" 线程 " + std::to_string(i)
+ " 第 " + std::to_string(round + 1) + " 轮");
// 线程0在第2轮后退出
if (i == 0 && round == 1) {
safe_print(" 线程 0 退出同步(arrive_and_drop)");
sync.arrive_and_drop(); // 永久减少参与者数量
return;
}
sync.arrive_and_wait();
}
});
}
}
// ============================
// 示例5:模拟迭代计算(雅可比迭代)
// ============================
void iterative_computation_demo() {
// 模拟简单的并行迭代计算
constexpr int size = 8;
constexpr int iterations = 3;
constexpr int num_threads = 2;
std::vector<double> current(size, 1.0);
std::vector<double> next(size, 0.0);
auto on_iteration_done = [&]() noexcept {
// 每轮结束后交换 current 和 next
std::swap(current, next);
};
std::barrier sync(num_threads, on_iteration_done);
std::vector<std::jthread> threads;
int chunk_size = size / num_threads;
for (int t = 0; t < num_threads; t++) {
int start = t * chunk_size;
int end = (t == num_threads - 1) ? size : start + chunk_size;
threads.emplace_back([&, start, end] {
for (int iter = 0; iter < iterations; iter++) {
// 每个线程处理自己的数据块
for (int i = start; i < end; i++) {
next[i] = current[i] * 0.5 + 0.25;
}
// 等待所有线程完成本轮计算
sync.arrive_and_wait();
}
});
}
// 等待所有线程完成(jthread 析构自动 join)
threads.clear();
safe_print("最终结果:");
for (int i = 0; i < size; i++) {
safe_print(" data[" + std::to_string(i) + "] = "
+ std::to_string(current[i]));
}
}
// ============================
// 示例6:无完成回调的 barrier
// ============================
void no_callback_demo() {
constexpr int num_threads = 3;
// 不提供完成回调——使用默认的空操作
std::barrier sync(num_threads);
std::vector<std::jthread> threads;
for (int i = 0; i < num_threads; i++) {
threads.emplace_back([&sync, i] {
safe_print(" 线程 " + std::to_string(i) + " 第一阶段");
sync.arrive_and_wait();
safe_print(" 线程 " + std::to_string(i) + " 第二阶段");
sync.arrive_and_wait();
});
}
}
int main() {
std::cout << "=== 基本多轮同步 ===" << std::endl;
basic_demo();
std::cout << "\n=== 分阶段处理 ===" << std::endl;
pipeline_demo();
std::cout << "\n=== arrive/wait 分离 ===" << std::endl;
separate_arrive_wait_demo();
std::cout << "\n=== arrive_and_drop ===" << std::endl;
drop_demo();
std::cout << "\n=== 迭代计算 ===" << std::endl;
iterative_computation_demo();
std::cout << "\n=== 无回调 ===" << std::endl;
no_callback_demo();
return 0;
}barrier vs latch
| 特性 | std::barrier | std::latch |
|---|---|---|
| 可重用 | 可以(多轮) | 不可以(一次性) |
| 完成回调 | 支持 | 不支持 |
| 参与者退出 | arrive_and_drop | 不支持 |
| 计数器重置 | 每轮自动重置 | 不重置 |
| 适用场景 | 多轮迭代同步 | 一次性等待 |
| arrive/wait 分离 | 支持 | 支持 |
barrier 的工作流程
初始化: expected = N(参与线程数)
每轮(phase):
1. 线程调用 arrive() 或 arrive_and_wait()
2. 计数器递减
3. 当计数器归零:
a. 执行完成回调 completion()
b. 计数器重置为 expected
c. 释放所有等待的线程
4. 进入下一轮适用场景
- 并行迭代计算(雅可比迭代、矩阵运算)
- 分阶段的数据处理管道
- 多轮同步的工作线程池
- 游戏引擎的帧同步
- 需要在同步点执行汇总操作的场景
常见问题
完成回调在哪个线程执行?
在最后一个到达的线程中同步执行。执行期间其他线程保持等待。
完成回调有什么限制?
回调必须是 noexcept 的(不能抛出异常),并且必须满足 MoveConstructible 和 Destructible 要求。
arrive_and_drop 之后会怎样?
调用线程不再参与后续轮次,barrier 的 expected 计数永久减 1。后续轮次只需要剩余线程到达即可完成。
arrive() 返回的 token 可以在不同轮次使用吗?
不可以。arrival_token 只能用于当前轮或紧接着的下一轮的 wait()。
注意事项
- barrier 不能复制或移动
- 完成回调必须是 noexcept 的
- arrive_and_drop 永久减少参与者——不能撤销
- 不要在完成回调中调用 barrier 自身的成员函数
- arrival_token 不能跨轮次使用
- expected 为 0 时构造 barrier 是合法的,但没有线程能到达
总结
std::barrier 是 C++20 引入的可重用多轮同步原语。与一次性的 std::latch 不同,barrier 每轮所有线程到达后自动重置计数器,进入下一轮。它支持完成回调——在每轮结束时由最后到达的线程执行,适合汇总数据或交换缓冲区。arrive_and_drop 允许线程永久退出同步,减少后续轮次的参与者数量。barrier 适用于并行迭代计算、分阶段处理管道、帧同步等需要多轮同步的场景。