条件变量、引用和线程：谁拥有锁？

Question

假设我有一个持有std::queue 的类ThreadQueue，并且我将每个std::ref 的一个实例传递给一个线程。进一步假设，线程 1（主线程）创建并持有 ThreadQueue 对象并将消息倒入其中，第二个线程的任务是在收到这些消息时将它们放在某个地方，例如，将它们写入日志文件。

类看起来像：

#include <queue>
#include <mutex>
#include <condition_variable>

using namespace std;

template <typename T>
class ThreadQueue
{
    queue<T> q_;
    mutex mtx;
    unique_lock<mutex> lck;
    condition_variable cv;

public:
    ThreadQueue() { lck = unique_lock<mutex>(mtx); }
    ~ThreadQueue() { if (lck.owns_lock()) lck.unlock(); }

    void enqueue (const T&);
    T dequeue ();
};

template <typename T>
void ThreadQueue<T>::enqueue (const T& t)
{
    lck.lock();
    q_.push(t);
    lck.unlock();
    cv.notify_one();
}

template <typename T>
T ThreadQueue<T>::dequeue ()
{
    cv.wait(lck);
    lck.lock();
    T t = q_.front(); // let's assume that's a copy assignment, because
    q_.pop();         // pop() calls the descructor.
    lck.unlock();
    return t;
}

然后主要的曲调是：

ThreadQueue<std::pair<int, std::string>> logs;
// and maybe something like:
std::thread logger(std::ref(logs));

关键行是cv.wait(lck); 文档明确指出lck 必须是一个unique_lock 对象，其互斥对象当前已被该线程锁定。

现在的问题是：谁真正锁定了互斥锁，谁拥有锁，线程 1 还是线程 2？

Answer 1

代码中有两个主要错误：

1. unique_lock 不应该是成员变量。它必须在堆栈上创建，以便在离开作用域时（正常返回或异常时）自动为您释放锁。
2. cv.wait 必须在您检查队列确实为空后才能调用。 std::condition_variable 是一种无状态通信机制，如果在没有服务员的情况下发出信号，则信号丢失。也有虚假的唤醒。您可能希望使用 cv.wait([this] { return !q_.empty(); }); 为您正确处理条件变量的等待。

例如：

using namespace std;

template <typename T>
class ThreadQueue
{
    queue<T> q_;
    mutex mtx;
    condition_variable cv;

public:
    void enqueue (const T&);
    T dequeue ();
};

template <typename T>
void ThreadQueue<T>::enqueue (const T& t)
{
    {
        lock_guard<mutex> lck(mtx);
        q_.push(t);
    }
    cv.notify_one(); // Optimization: release the lock before signalling.
}

template <typename T>
T ThreadQueue<T>::dequeue ()
{
    unique_lock<mutex> lck(mtx);
    cv.wait(lck, [this] { return !q_.empty(); });
    T t = q_.front();
    q_.pop();
    return t;
}

谁拥有锁？

已锁定互斥锁的线程拥有锁，或进入临界区。 std::lock_guard 和 std::unique_lock 都在这里将互斥锁锁定在构造函数中并在析构函数中解锁（在正常范围退出或异常时）。