c++ - boost condition_variable 等待多个锁

Question

我在习惯线程编程方面遇到了问题。我试图构建一个带有互斥锁和锁的结构。但我需要 boost::condition_variable::wait 两个锁作为参数。但是没有两个锁的wait函数。

有没有人给我提示，或者我的方法完全错误？

我的目标是

• 允许并发添加()，将所有内容写入缓冲区
• 一个工作线程 operator()()，存储缓冲值
• 和一个search()，在搜索前等待工作线程

    class Archive
    {
        vector externalBuffer;
        vector swapBuffer;
        vector internalBuffer;
        boost::mutex externalBufferMutex;
        boost::mutex allBufferMutex;
        boost::condition_variable bufferIsFilledConditionVariable;

        void operator () ()
        {
            unique_lock allBufferLock(allBufferMutex);
            while(true)
            {
                {
                    unique_lock lock(externalBufferMutex);
                    while(buffer.empty())
                    {
                        bufferIsFilledConditionVariable.wait(...); // I should call it with two locks?
                    }
                    externalBuffer.swap(swapBuffer);
                }

                {
                    internalBuffer.swap(swapBuffer);
                    // store values from internalBuffer
                    ...
                    internalBuffer.clear();
                }
            }
        }

        void add(value) // pseudo code here
        {
            {
                lock_guard lock(externalBufferMutex);
                externalBuffer.push_back(value);
            }
            bufferIsFilledConditionVariable.notify_one();
        }

        // search will not be used concurrently with add()
        // it should just wait for the worker thread
        someReturnValue search()
        {
            unique_lock lock(allBufferMutex);
            // search here
            ...
        }

    }

Answer 1

我不确定您要达到什么目的，一般来说，您应该避免在多个重叠的锁下操作。

但是，一般来说，为了避免死锁，您只需使用一致的锁顺序。非成员 lock 函数可以帮助解决这个问题:

• http://www.boost.org/doc/libs/1_56_0/doc/html/thread/synchronization.html#thread.synchronization.lock_functions.lock_multiple

  Locks the Lockable objects supplied as arguments in an unspecified and indeterminate order in a way that avoids deadlock. It is safe to call this function concurrently from multiple threads with the same mutexes (or other lockable objects) in different orders without risk of deadlock. If any of the lock() or try_lock() operations on the supplied Lockable objects throws an exception any locks acquired by the function will be released before the function exits.

• http://en.cppreference.com/w/cpp/thread/lock (对于 C++11)

例子

unique_lock lk_all(allBufferMutex,      boost::defer_lock);
unique_lock lk_ext(externalBufferMutex, boost::defer_lock);
boost::lock(lk_all, lk_ext);

while(internalBuffer.empty())
{
    lk_all.unlock();
    bufferIsFilledConditionVariable.wait(lk_ext);
    boost::lock(lk_all, lk_ext);
}

这是未经测试的，但可能对您有所帮助