C++ 中的 acquire-release 语义与信号量同步实践

在多线程编程中，正确协调线程间的数据访问与状态传递是构建可靠并发系统的核心挑战。C++11 引入了标准化的内存模型和原子操作，其中 memory_order_acquire 与 memory_order_release 构成了最常用且高效的同步原语之一。它们虽不直接实现信号量（semaphore），却为用户态信号量、锁、生产者-消费者队列等高级同步结构提供了底层语义保障。本文将深入解析 acquire-release 操作的语义本质，并通过一个轻量级二值信号量（binary semaphore）的完整实现，展示其在实际并发控制中的应用逻辑与注意事项。

acquire-release 并非独立的“操作”，而是对原子读写施加的内存顺序约束。release 写操作保证：在其之前的所有内存读写（包括非原子变量）不会被重排到该写之后；acquire 读操作则保证：在其之后的所有内存读写不会被重排到该读之前。当一个线程以 release 方式写入某个原子变量，而另一线程以 acquire 方式读取到该值时，就建立起一条“synchronizes-with”关系——这使得前一线程的所有先行操作，对后一线程而言全部可见。这种语义恰好契合信号量“通知-等待”的典型模式：释放资源（release）后，等待方（acquire）能安全观察到状态变更及关联数据。

下面是一个基于 std::atomic<int> 实现的二值信号量类。它仅支持 wait()（P 操作）与 signal()（V 操作），内部使用自旋等待，适用于低竞争场景：

#include <atomic>
#include <thread>
#include <vector>
#include <chrono>

class binary_semaphore {
private:
    std::atomic<int> counter_;

public:
    explicit binary_semaphore(int initial = 1) : counter_(initial) {}

    // 等待信号量变为正数；成功后减一并返回
    void wait() {
        while (true) {
            int expected = 1;
            // 原子比较并交换：若当前值为1，则设为0
            if (counter_.compare_exchange_strong(expected, 0,
                std::memory_order_acquire,  // 成功时：acquire语义，确保后续读可见
                std::memory_order_relaxed)) {  // 失败时：无需同步，仅重试
                return;
            }
            // 若失败（expected被更新为当前值），检查是否为0
            // 若为0，需短暂让出CPU以避免忙等过度消耗
            if (expected == 0) {
                std::this_thread::yield();
            }
        }
    }

    // 释放信号量：将计数器从0设为1
    void signal() {
        // 原子写入1，使用release语义
        // 确保此前所有写操作（如共享数据初始化）对wait()线程可见
        counter_.store(1, std::memory_order_release);
    }
};

该实现的关键在于 wait() 中 compare_exchange_strong 的内存序选择：成功路径采用 memory_order_acquire，使后续对共享数据的访问（例如读取刚被生产的任务）不会被重排至 wait() 之前；signal() 则使用 memory_order_release，确保 signal() 前对共享数据（如任务缓冲区）的写入，在 wait() 成功返回后必然可见。二者共同构成完整的 acquire-release 同步链。

为验证其正确性，考虑一个典型生产者-消费者场景：生产者线程生成整数并存入全局变量 shared_data，随后调用 sem.signal()；消费者调用 sem.wait() 后读取 shared_data。若无 acquire-release 保证，编译器或处理器可能重排指令，导致消费者读到未初始化或过期的值。而本实现可严格避免此类数据竞争。

以下为测试代码片段，启动两个线程模拟单次协作：

#include <iostream>

int shared_data = 0;
binary_semaphore sem(0);  // 初始不可用

void producer() {
    shared_data = 42;                    // 写入共享数据
    std::this_thread::sleep_for(std::chrono::milliseconds(10));
    sem.signal();                        // release：发布状态变更
}

void consumer() {
    sem.wait();                          // acquire：等待并建立同步点
    std::cout << "Consumed: " << shared_data << "\n";  // 安全读取
}

int main() {
    std::thread t1(producer);
    std::thread t2(consumer);
    t1.join();
    t2.join();
    return 0;
}

运行结果始终输出 Consumed: 42，证明 acquire-release 成功建立了跨线程的 happens-before 关系。值得注意的是，memory_order_acquire 和 memory_order_release 本身不提供互斥或阻塞能力，它们仅约束内存访问顺序；真正的“等待”逻辑由循环+CAS+yield 构成，属于算法层面设计。

在工程实践中，应谨慎评估自旋等待的适用性。高竞争或长等待场景下，建议结合 std::condition_variable 或操作系统原生信号量；但若等待时间极短（如微秒级），自旋可避免上下文切换开销，此时 acquire-release 是最优选择。此外，std::atomic_flag 提供更轻量的 test-and-set 原语，亦可用于实现类似语义，但接口更底层。

总之，acquire-release 不是魔法，而是程序员手中一把精准的“内存序刻刀”。理解其同步边界、合理搭配原子操作与算法逻辑，方能在 C++ 并发世界中构建既高效又正确的信号量抽象。掌握这一机制，不仅提升对标准库同步设施的理解深度，更是编写高性能、可移植并发代码的坚实基础。

文章结束。