同一互斥锁上有多个锁，一个永远锁定

Question

在我的程序中，我有一个互斥锁和两个线程。其中一个线程经常获取锁。另一个线程试图获取，但必须永远等待。

是否会因为释放锁后很快就获得了锁，而另一个线程没有机会获得锁？互斥总是给每个人一个机会吗？如果不是，什么是好的解决方案？（某种FIFO锁？）

我使用的是std：：mutex和std：：lock\u guard

问题扩展seccpur指出，std：：condition\u变量可以解决这个问题。三个线程如何伸缩？std：：condition\u变量是否确保每个线程都有一个回合？假设您使用notify\u one（）。

Answer 1

使用std::互斥锁、std::lock_guard、std::unique_lock（读取器）和std::condition_variable的示例。_mutexLockCondition、_mutexObject和_dataContainer在ReaderClass和WriterClass之间共享。

试图对实际的数据容器有点含糊不清，所以由您决定。

std::shared_ptr< Data > ReaderClass::read()
{
    std::unique_lock< std::mutex > lock( _mutexObject );

    // handle spurious wakeup from waitForMessageNotification
    while( _dataContainer.empty() )
    {
        if( waitForMessageNotification( lock ) )
        {
            // timeout occurred, return nullptr to prevent blocking
            return nullptr;
        }
    }

    return getDataFromContainer();
}

bool ReaderClass::waitForNotification( unique_lock< mutex > & lock )
{
    //_mutexLockCondition is a std::condition_variable
    return _mutexLockCondition.wait_for( lock, std::chrono::milliseconds( 100 ) )
                                            == std::cv_status::timeout;
}


void WriterClass::write( std::shared_ptr< Data > dataPtr )
{
    std::lock_guard< mutex > lock( _mutexObject );

    addDataToContainer( dataPtr );

    _mutexLockCondition.notify_one();
}

Answer 2

利用seccpur的提示，我想出了以下解决方案来防止耗尽单个线程。

#include <condition_variable>
#include <mutex>
#include <atomic>

class NoStarveLock
{
    std::condition_variable condition;
    std::atomic_flag flag = ATOMIC_FLAG_INIT;
    std::mutex conditionLock;
public:
    void lock()
    {
        std::unique_lock<std::mutex> lck(conditionLock);
        while (flag.test_and_set()) // multiple threads can wake up at the same time, so use a set+test
        {
            condition.wait(lck); // wait for a wakeup
        }
    }

    void unlock()
    {
        std::unique_lock<std::mutex> lck(conditionLock);
        flag.clear();
        condition.notify_all();
    }
};

Answer 3

互斥不能保证给每个人平等的机会。因此，一个线程可能会使另一个线程饥饿。您可以尝试的第一件事是插入std：：this\u thread：：yield（），看看是否有帮助。如果这没有帮助，那么您的代码一定有逻辑错误。发布部分代码，我们可以帮助您进一步诊断。