std::binary_semaphore ​

什么是 std::binary_semaphore ​

std::binary_semaphore 是 C++20 引入的同步原语,定义在 <semaphore> 头文件中。它本质上是 std::counting_semaphore<1> 的类型别名,计数器只能是 0 或 1。

cpp
// 标准库定义
using binary_semaphore = std::counting_semaphore<1>;

binary_semaphore 的计数器在 0 和 1 之间切换,语义类似于互斥锁,但有一个关键区别:它不绑定线程。一个线程可以 acquire(获取),另一个线程可以 release(释放)。这让它特别适合线程间的信号通知。

binary_semaphore vs mutex ​

特性binary_semaphorestd::mutex
所有权不绑定线程绑定线程(谁锁谁解)
跨线程释放可以不可以(未定义行为)
初始状态可以选择(0或1)总是未锁定
超时获取try_acquire_for需要 timed_mutex
递归锁定不支持需要 recursive_mutex
典型用途信号通知、事件同步互斥访问共享数据

基本示例 ​

cpp
#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, &notifications, 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 模式。