std::latch 同步原语
什么是 std::latch
std::latch 是 C++20 引入的一次性倒计数同步原语,定义在 <latch> 头文件中。它维护一个内部计数器,线程可以递减计数器并等待计数器归零。一旦计数器到达零,所有等待的线程被释放,latch 不能重置或重用。
latch 常用于"等待所有线程完成某个阶段"的场景——比如等待所有工作线程初始化完毕,或者等待所有数据加载完成。
cpp
#include <latch>
std::latch done(3); // 计数器初始化为 3
// 每个线程完成工作后调用 done.count_down()
// 主线程调用 done.wait() 等待计数器归零latch 的成员函数
| 函数 | 说明 |
|---|---|
latch(n) | 构造,计数器初始化为 n |
count_down(n=1) | 原子地将计数器减 n(不阻塞) |
try_wait() | 检查计数器是否为零(不阻塞) |
wait() | 阻塞直到计数器为零 |
arrive_and_wait(n=1) | 等价于 count_down(n) + wait() |
max() | 静态函数,返回计数器支持的最大值 |
基本示例
cpp
#include <iostream>
#include <thread>
#include <latch>
#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_workers = 5;
std::latch work_done(num_workers);
std::vector<std::jthread> workers;
for (int i = 0; i < num_workers; i++) {
workers.emplace_back([&work_done, i] {
// 模拟不同时长的工作
std::this_thread::sleep_for(std::chrono::milliseconds(50 * (i + 1)));
safe_print(" 工作线程 " + std::to_string(i) + " 完成");
work_done.count_down(); // 完成后递减计数器
});
}
// 主线程等待所有工作完成
work_done.wait();
safe_print("所有工作线程已完成");
}
// ============================
// 示例2:Boss-Worker 模式
// ============================
void boss_worker_demo() {
constexpr int num_workers = 4;
// 两个 latch:一个让 boss 等工人完成,一个让工人等 boss 发令
std::latch ready(num_workers); // 工人准备就绪
std::latch go(1); // boss 发出开始信号
std::vector<std::jthread> workers;
for (int i = 0; i < num_workers; i++) {
workers.emplace_back([&ready, &go, i] {
// 准备阶段
safe_print(" 工人 " + std::to_string(i) + " 准备就绪");
ready.count_down(); // 通知 boss 自己准备好了
// 等待 boss 发令
go.wait();
// 开始工作
safe_print(" 工人 " + std::to_string(i) + " 开始工作");
});
}
// Boss 等待所有工人准备就绪
ready.wait();
safe_print("Boss: 所有工人已准备就绪");
// Boss 发出开始信号
safe_print("Boss: 开始!");
go.count_down();
}
// ============================
// 示例3:arrive_and_wait
// ============================
void arrive_and_wait_demo() {
constexpr int num_threads = 4;
std::latch sync_point(num_threads);
std::vector<std::jthread> threads;
for (int i = 0; i < num_threads; i++) {
threads.emplace_back([&sync_point, i] {
// 第一阶段工作
safe_print(" 线程 " + std::to_string(i) + " 完成第一阶段");
// arrive_and_wait = count_down + wait
// 递减计数器并等待所有线程到达
sync_point.arrive_and_wait();
// 所有线程都到达后才继续
safe_print(" 线程 " + std::to_string(i) + " 开始第二阶段");
});
}
}
// ============================
// 示例4:数据加载同步
// ============================
void data_loading_demo() {
struct DataSource {
std::string name;
int load_time_ms;
};
std::vector<DataSource> sources = {
{"数据库", 100},
{"配置文件", 50},
{"缓存", 30},
};
std::latch all_loaded(sources.size());
std::vector<std::string> loaded_data(sources.size());
std::vector<std::jthread> loaders;
for (size_t i = 0; i < sources.size(); i++) {
loaders.emplace_back([&, i] {
// 模拟加载
std::this_thread::sleep_for(
std::chrono::milliseconds(sources[i].load_time_ms));
loaded_data[i] = sources[i].name + " 已加载";
safe_print(" " + sources[i].name + " 加载完成");
all_loaded.count_down();
});
}
// 等待所有数据源加载完成
all_loaded.wait();
safe_print("所有数据源加载完成,开始处理:");
for (const auto& d : loaded_data) {
safe_print(" " + d);
}
}
// ============================
// 示例5:try_wait 非阻塞检查
// ============================
void try_wait_demo() {
std::latch done(2);
std::jthread t1([&done] {
std::this_thread::sleep_for(std::chrono::milliseconds(100));
done.count_down();
});
std::jthread t2([&done] {
std::this_thread::sleep_for(std::chrono::milliseconds(200));
done.count_down();
});
// 非阻塞轮询
while (!done.try_wait()) {
safe_print(" 还没完成,做其他事...");
std::this_thread::sleep_for(std::chrono::milliseconds(50));
}
safe_print("全部完成");
}
// ============================
// 示例6:一次递减多个
// ============================
void multi_count_demo() {
std::latch done(10);
std::jthread t1([&done] {
safe_print(" 线程1: 完成 3 个任务");
done.count_down(3); // 一次递减 3
});
std::jthread t2([&done] {
safe_print(" 线程2: 完成 7 个任务");
done.count_down(7); // 一次递减 7
});
done.wait();
safe_print("10 个任务全部完成");
}
int main() {
std::cout << "=== 等待所有工作线程 ===" << std::endl;
basic_demo();
std::cout << "\n=== Boss-Worker ===" << std::endl;
boss_worker_demo();
std::cout << "\n=== arrive_and_wait ===" << std::endl;
arrive_and_wait_demo();
std::cout << "\n=== 数据加载 ===" << std::endl;
data_loading_demo();
std::cout << "\n=== try_wait ===" << std::endl;
try_wait_demo();
std::cout << "\n=== 多计数 ===" << std::endl;
multi_count_demo();
return 0;
}latch vs barrier vs condition_variable
| 特性 | std::latch | std::barrier | condition_variable |
|---|---|---|---|
| 可重用 | 不可以(一次性) | 可以(可重复使用) | 可以 |
| 使用复杂度 | 简单 | 中等 | 复杂(需要 mutex) |
| 完成回调 | 不支持 | 支持 | 不支持 |
| 计数器方向 | 只能递减 | 每轮自动重置 | 需要手动管理 |
| 典型用途 | 一次性等待所有线程 | 多轮同步 | 通用等待/通知 |
适用场景
- 等待多个线程完成初始化
- 等待所有数据加载完毕后再处理
- 多线程测试中同步所有线程同时开始
- 一次性的"所有线程到达某个点"同步
- 替代 condition_variable 的简单等待模式
常见问题
latch 用完后可以重置吗?
不可以。latch 是一次性的。如果需要重复同步,使用 std::barrier。
count_down 的参数可以超过当前计数器值吗?
不可以。如果参数大于计数器当前值,行为是未定义的。
latch 比 condition_variable 好在哪里?
latch 不需要配合 mutex 使用,接口更简单,更不容易出错。对于"等待计数器归零"这个特定模式,latch 是最直接的工具。
latch 的所有操作都是线程安全的吗?
是的。count_down、wait、try_wait、arrive_and_wait 的并发调用不会产生数据竞争。
注意事项
- latch 是一次性的,计数器归零后不能重置
- count_down 的参数不能超过计数器当前值
- count_down 不阻塞,wait 阻塞
- arrive_and_wait 等价于 count_down + wait
- latch 不能被复制或移动
- 析构 latch 时,不能有线程在 wait
总结
std::latch 是 C++20 引入的一次性倒计数同步原语,用于等待一组线程到达某个同步点。它比 condition_variable + mutex 的组合更简单直接——只需要初始化计数器,每个线程完成后 count_down,等待方调用 wait。latch 的所有操作都是线程安全的。它适合"等待所有线程完成某件事"的一次性场景,如初始化同步、数据加载同步等。如果需要多轮重复同步,应该使用 std::barrier。