std::binary_semaphore
什么是 std::binary_semaphore
std::binary_semaphore 是 C++20 引入的同步原语,定义在 <semaphore> 头文件中。它本质上是 std::counting_semaphore<1> 的类型别名,计数器只能是 0 或 1。
// 标准库定义
using binary_semaphore = std::counting_semaphore<1>;binary_semaphore 的计数器在 0 和 1 之间切换,语义类似于互斥锁,但有一个关键区别:它不绑定线程。一个线程可以 acquire(获取),另一个线程可以 release(释放)。这让它特别适合线程间的信号通知。
binary_semaphore vs mutex
| 特性 | binary_semaphore | std::mutex |
|---|---|---|
| 所有权 | 不绑定线程 | 绑定线程(谁锁谁解) |
| 跨线程释放 | 可以 | 不可以(未定义行为) |
| 初始状态 | 可以选择(0或1) | 总是未锁定 |
| 超时获取 | try_acquire_for | 需要 timed_mutex |
| 递归锁定 | 不支持 | 需要 recursive_mutex |
| 典型用途 | 信号通知、事件同步 | 互斥访问共享数据 |
基本示例
#include <iostream>
#include <thread>
#include <semaphore>
#include <vector>
#include <mutex>
#include <string>
#include <chrono>
#include <queue>
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 signal_demo() {
// 初始值为0:接收方必须等发送方通知
std::binary_semaphore signal(0);
std::string message;
std::jthread sender([&] {
std::this_thread::sleep_for(std::chrono::milliseconds(100));
message = "来自发送线程的消息";
safe_print(" 发送方: 消息已准备");
signal.release(); // 通知接收方
});
std::jthread receiver([&] {
safe_print(" 接收方: 等待消息...");
signal.acquire(); // 等待通知
safe_print(" 接收方: 收到 -> " + message);
});
}
// ============================
// 示例2:乒乓(Ping-Pong)同步
// ============================
void ping_pong_demo() {
std::binary_semaphore ping_signal(0);
std::binary_semaphore pong_signal(0);
constexpr int rounds = 5;
std::jthread ping_thread([&] {
for (int i = 0; i < rounds; i++) {
pong_signal.acquire(); // 等待 pong 完成(第一轮由主线程启动)
safe_print(" Ping " + std::to_string(i + 1));
ping_signal.release(); // 通知 pong 线程
}
});
std::jthread pong_thread([&] {
for (int i = 0; i < rounds; i++) {
ping_signal.acquire(); // 等待 ping 完成
safe_print(" Pong " + std::to_string(i + 1));
pong_signal.release(); // 通知 ping 线程
}
});
// 启动第一轮
pong_signal.release();
}
// ============================
// 示例3:用作简单锁
// ============================
void lock_demo() {
// 初始值为1:表示资源可用
std::binary_semaphore lock(1);
int shared_counter = 0;
std::vector<std::jthread> threads;
for (int i = 0; i < 5; i++) {
threads.emplace_back([&lock, &shared_counter] {
for (int j = 0; j < 1000; j++) {
lock.acquire(); // 相当于 lock
shared_counter++;
lock.release(); // 相当于 unlock
}
});
}
threads.clear(); // 等待所有线程完成
std::cout << "计数器: " << shared_counter << std::endl; // 5000
}
// ============================
// 示例4:任务完成通知
// ============================
void task_notification_demo() {
struct Task {
std::string name;
int duration_ms;
};
std::vector<Task> tasks = {
{"加载配置", 50},
{"连接数据库", 100},
{"初始化缓存", 70},
};
// 每个任务一个通知信号量
std::vector<std::binary_semaphore> notifications;
for (size_t i = 0; i < tasks.size(); i++) {
notifications.emplace_back(0); // 初始为0,等待完成
}
// 启动任务线程
std::vector<std::jthread> workers;
for (size_t i = 0; i < tasks.size(); i++) {
workers.emplace_back([&tasks, ¬ifications, i] {
// 模拟任务执行
std::this_thread::sleep_for(
std::chrono::milliseconds(tasks[i].duration_ms));
safe_print(" " + tasks[i].name + " 完成");
notifications[i].release(); // 通知完成
});
}
// 按顺序等待每个任务完成
for (size_t i = 0; i < tasks.size(); i++) {
notifications[i].acquire();
safe_print(" 确认: " + tasks[i].name + " 已就绪");
}
safe_print("所有任务完成,系统启动");
}
// ============================
// 示例5:try_acquire 非阻塞检查
// ============================
void try_acquire_demo() {
std::binary_semaphore sem(0);
// 非阻塞尝试
bool got = sem.try_acquire();
std::cout << std::boolalpha;
std::cout << "try_acquire (empty): " << got << std::endl; // false
sem.release();
got = sem.try_acquire();
std::cout << "try_acquire (after release): " << got << std::endl; // true
}
// ============================
// 示例6:限时等待
// ============================
void timed_demo() {
std::binary_semaphore sem(0);
std::jthread delayed_release([&] {
std::this_thread::sleep_for(std::chrono::milliseconds(150));
sem.release();
});
// 等待 50ms——会超时
auto start = std::chrono::steady_clock::now();
bool r1 = sem.try_acquire_for(std::chrono::milliseconds(50));
auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(
std::chrono::steady_clock::now() - start).count();
safe_print(" 50ms 等待: " + std::string(r1 ? "成功" : "超时")
+ " (" + std::to_string(elapsed) + "ms)");
// 再等 200ms——会成功
start = std::chrono::steady_clock::now();
bool r2 = sem.try_acquire_for(std::chrono::milliseconds(200));
elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(
std::chrono::steady_clock::now() - start).count();
safe_print(" 200ms 等待: " + std::string(r2 ? "成功" : "超时")
+ " (" + std::to_string(elapsed) + "ms)");
}
// ============================
// 示例7:顺序执行保证
// ============================
void ordering_demo() {
// 保证三个阶段按顺序执行
std::binary_semaphore phase1_done(0);
std::binary_semaphore phase2_done(0);
std::jthread t3([&] {
phase2_done.acquire(); // 等第二阶段完成
safe_print(" 阶段3: 结果汇总");
});
std::jthread t2([&] {
phase1_done.acquire(); // 等第一阶段完成
safe_print(" 阶段2: 数据处理");
std::this_thread::sleep_for(std::chrono::milliseconds(50));
phase2_done.release();
});
std::jthread t1([&] {
safe_print(" 阶段1: 数据加载");
std::this_thread::sleep_for(std::chrono::milliseconds(50));
phase1_done.release();
});
}
int main() {
std::cout << "=== 信号通知 ===" << std::endl;
signal_demo();
std::cout << "\n=== 乒乓同步 ===" << std::endl;
ping_pong_demo();
std::cout << "\n=== 用作锁 ===" << std::endl;
lock_demo();
std::cout << "\n=== 任务通知 ===" << std::endl;
task_notification_demo();
std::cout << "\n=== try_acquire ===" << std::endl;
try_acquire_demo();
std::cout << "\n=== 限时等待 ===" << std::endl;
timed_demo();
std::cout << "\n=== 顺序执行 ===" << std::endl;
ordering_demo();
return 0;
}适用场景
- 线程间一对一信号通知
- 保证操作的先后顺序
- 乒乓式交替执行
- 任务完成通知
- 替代 condition_variable 的简单唤醒场景
常见问题
binary_semaphore 和 counting_semaphore<1> 完全一样吗?
是的。binary_semaphore 只是 counting_semaphore<1> 的类型别名,接口完全相同。
binary_semaphore 能代替 mutex 吗?
技术上可以用 binary_semaphore 实现互斥访问,但不推荐。mutex 有所有权语义(RAII 配合 lock_guard),更适合保护临界区。binary_semaphore 更适合信号通知。
release 两次不 acquire 会怎样?
计数器不能超过 1(因为 LeastMaxValue 是 1)。如果 release 后计数器已经是 1,再次 release 是未定义行为。
binary_semaphore 是线程安全的吗?
是的。所有成员函数都是线程安全的。
注意事项
- 计数器只能是 0 或 1
- release 时计数器已经是 1 是未定义行为
- 不绑定线程——acquire 和 release 可以在不同线程
- 用于互斥时不如 mutex + lock_guard 安全
- 析构时不能有线程在 acquire 等待
- 需要
<semaphore>头文件
总结
std::binary_semaphore 是 std::counting_semaphore<1> 的别名,计数器在 0 和 1 之间切换。它最核心的特点是不绑定线程——一个线程 acquire,另一个线程 release,这让它成为线程间信号通知的理想工具。典型用法包括:初始值设为 0 让接收方等待发送方通知、乒乓式交替执行、保证操作的先后顺序等。虽然它可以用作简单锁,但保护临界区还是推荐使用 mutex + lock_guard 的 RAII 模式。