单读单写线程下非原子bool同步共享vector的线程安全性验证

我希望构建一种高效的同步模型，在两个线程间共享消息队列，设计了一个包含vector、mutex和dirty标志的类，代码如下：

#include <vector>
#include <mutex>

class SharedVector {
    std::mutex vector_lock;
    std::vector<int> vec;
    volatile bool dirty = false;

    void write(int a) {
        std::unique_lock lock(vector_lock);
        vec.push_back(a);                // Step 1
        dirty = true;                       // Step 2
    }

    void consume(std::vector<int>& container) {
        if (dirty) {
            std::unique_lock lock(vector_lock);
            container = std::move(vec);         // Invalidates original vec
            dirty = false;
        }
    } 
};

我假设该实现是线程安全的，尽管dirty标志在锁外被读取，但对此存疑，我的推理如下：

• 所有对dirty标志的写入都在锁保护的原子区域内，确保同一时间只有一个线程写入该标志。
• 尽管CPU指令重排可能导致dirty标志先被设为true（write()中的Step2），再执行vector追加操作（Step1），但consume()线程必须等待write()线程释放锁，因此不会有问题。
• 根据x86的缓存一致性协议（MESI或MOESI），write()线程写入dirty标志后会使其失效。

请问该实现是否真的线程安全？存在哪些缺陷？我避免将dirty标志设为atomic，因为这会导致显著的性能下降，而我正试图避免这一点。

补充约束：

1. 仅存在一个读线程和一个写线程。
2. consume()函数必须是非阻塞的，因为若无消息可用，读线程还有其他工作要处理。

你的实现不是线程安全的，存在多个关键缺陷，下面逐一分析：

1. volatile无法解决核心的线程同步问题 #

你依赖volatile bool dirty传递状态，但C++中的volatile仅保证变量读写不会被编译器优化删除，不提供线程间的内存可见性保证，也无法阻止CPU的指令重排（不能依赖x86架构的特性写可移植代码）。

比如write()中，编译器或CPU可能重排Step1和Step2的执行顺序；即使顺序正确，写线程释放锁时，dirty=true的写入也可能未同步到读线程的缓存，导致读线程持续看到dirty=false，直接丢失消息。

另外，consume()的锁外检查+锁内操作存在**检查-时间-使用（TOCTOU）**漏洞：

• 读线程看到dirty=true，准备加锁
• 此时写线程完成写入并释放锁，紧接着又执行一次write()（再次设dirty=true）
• 读线程加锁后，会把刚写入的新消息和旧消息一起move走并重置dirty=false，完全覆盖掉刚写入的内容，造成消息丢失。

2. 你的推理存在错误 #

• 关于指令重排：锁的释放仅保证锁内操作对后续加锁的线程可见，但读线程是在锁外读取dirty，锁的内存屏障无法作用于这个操作，读线程无法保证看到dirty的最新值。
• 关于x86缓存一致性：MESI协议保证缓存行最终一致，但不保证写入立即同步到所有核心，而且编译器仍可能重排dirty和vec修改的顺序（volatile不阻止编译器重排）。

3. 不用atomic也能高效实现？不，单生产者单消费者场景下atomic开销可忽略 #

你担心atomic性能下降，但单生产者单消费者场景中，std::atomic<bool>的load/store操作在x86下是无锁的，开销和普通bool几乎无差别，完全不会造成显著性能损耗。

修复后的安全实现 #

#include <vector>
#include <mutex>
#include <atomic>

class SharedVector {
    std::mutex vector_lock;
    std::vector<int> vec;
    std::atomic<bool> dirty = false;

    void write(int a) {
        std::unique_lock lock(vector_lock);
        vec.push_back(a);
        dirty.store(true, std::memory_order_release);
    }

    void consume(std::vector<int>& container) {
        if (dirty.load(std::memory_order_acquire)) {
            std::unique_lock lock(vector_lock);
            // 加锁后再次检查dirty，避免TOCTOU漏洞
            if (dirty.load(std::memory_order_relaxed)) {
                container = std::move(vec);
                dirty.store(false, std::memory_order_release);
            }
        }
    } 
};

关键优化点 #

• 用std::atomic<bool>配合内存序：memory_order_release保证vec的修改先于dirty的写入，memory_order_acquire保证读线程看到dirty=true时，能同步看到vec的所有修改。
• 加锁后二次检查dirty：彻底解决TOCTOU漏洞，避免消息被覆盖。
• 单生产者单消费者场景下，该实现性能和你的原始版本几乎一致，完全满足高效需求。

如果追求极致性能，还可以采用基于环形缓冲区的无锁单生产者单消费者队列，但上述实现已经足够覆盖绝大多数场景的安全与高效需求。

内容的提问来源于stack exchange，提问作者user22389543