为何为条件变量等待与pop()分别使用lock_guard会引发段错误？

问题背景 #

我实现了一个Packets类用于同步生产者与消费者线程的数据处理，设计中为条件变量等待（waitForReady）和队列弹出（pop）操作分别使用独立锁，但运行时出现段错误；将两个操作合并到同一锁内则正常运行。

初始实现代码 #

Packets类实现 #

class Packets
{
public:
    void finish()
    {
        {
            std::lock_guard lock(mMutex);
            mFinished = true;
        }
        mConditionVariable.notify_all();
    }
 
    void add(const Packet& packet) {
        {
            std::lock_guard lock(mMutex);
            mPackets.push(packet);
        }
        mConditionVariable.notify_one();
    }
 
    Packet pop()
    {
        std::lock_guard lock(mMutex);
        Packet packet = mPackets.front();
        mPackets.pop();
        return packet;
    }
 
    bool isFinished() const
    {
        return mFinished;
    }
 
    void waitForReady()
    {
        std::unique_lock lock(mMutex);
        mConditionVariable.wait(lock, [this] { return !mPackets.empty() || isFinished(); });
    }
 
private:
    std::queue<Packet> mPackets;
    std::mutex mMutex;
    std::condition_variable mConditionVariable;
    bool mFinished = false;
};

生产者与消费者函数 #

std::mutex pMutex;
 
void produce(Packets& packets)
{
    while(true) {
        std::this_thread::sleep_for(std::chrono::milliseconds(5000));
        Packet packet = generate_random_packet();
        packets.add(packet);
 
        std::lock_guard lock(pMutex);
        std::cout << "Packet created " << packet.source << " -> " << packet.destination << ": " << packet.data << std::endl;
    }
}
 
void consume(Packets& packets)
{
    while(true) {
        packets.waitForReady();
        if (packets.isFinished()) {
            std::cout << "Consume finished" << std::endl;
            return;
        }
        auto packet = packets.pop();
 
        std::lock_guard lock(pMutex);
        std::cout << "Received packet " << packet.source << " -> " << packet.destination << ": " << packet.data << std::endl;
    }
}

错误现象 #

运行代码时，有时会出现多消费者线程被唤醒后尝试从空队列调用pop()的情况，触发段错误，典型输出如下：

Packed created 17 -> 1: eQZm
Packed created 39 -> 36: FGTZ
Received packet 10 -> 54: YplK
Received packet 24 -> 50: aUNi
Received packet 0 -> 0: 
Received packet 0 -> 0: 
Received packet 0 -> 0: 
Packed created 99 -> 2: XCcT
Received packet 17 -> 1: eQZm
Received packet 39 -> 36: FGTZ
Segmentation fault (core dumped)

修复后的正常实现 #

将等待与弹出操作合并到同一锁内，代码运行正常：

Packet get()
{
    std::unique_lock lock(mMutex);
    mConditionVariable.wait(lock, [this] { return !mPackets.empty() || isFinished(); });
    Packet packet = mPackets.front();
    mPackets.pop();
    return packet;
}

问题原因分析 #

核心问题在于锁的分离导致线程安全的检查与操作之间出现了时间窗口：

• 当waitForReady返回时，虽然此时队列非空或已标记为结束，但释放锁后到调用pop的这段时间里，其他消费者线程可能已经把队列中的元素取走了。
• 比如多个消费者线程同时被唤醒（比如调用notify_all时），第一个线程通过waitForReady检查到队列非空，释放锁后，第二个线程也完成waitForReady的检查，此时第一个线程已经执行pop把队列掏空，第二个线程再调用pop时队列已经为空，调用front()就会触发未定义行为，导致段错误。
• 而合并锁的实现中，从条件变量等待结束到执行front()和pop()的整个过程都持有锁，确保了检查队列非空和取元素操作的原子性，不会被其他线程打断，彻底避免了空队列访问的问题。

另外，isFinished()的调用也存在线程安全问题：当前实现中isFinished没有加锁直接读取mFinished，而mFinished是被其他线程在锁内修改的，这会导致读取到脏数据，可能让消费者线程做出错误判断。合并锁的实现中，isFinished的检查是在锁内完成的，避免了这个问题。

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