Question

我有一个函数，其中语句foo应该在lock_guard下执行，但仅当指向mutex对象的指针作为参数提供给函数时。否则，foo不必受lock_guard 保护。

我无法在lock_guard中使用 if，因为当if块结束时，锁定会立即释放。

所以，这段代码是无稽之谈：

bar( std::mutex * optionalMutex = nullptr ) { ... if ( nullptr != optionalMutex ) { std::lock_guard<std::mutex> lockScope( *optionalMutex ); } <- Here the lock ends foo... <- foo is not protected when optionalMutex was provided }

我试过这样的事情：

bar( std::mutex * optionalMutex = nullptr ) { ... nullptr == optionalMutex ? 0 : std::lock_guard<std::mutex> lockScope( *optionalMutex ); // this scope should be protected by lock_guard when optionalMutex was provided foo... }

或多或少，对我来说唯一可行的解决方案是重复foo：

bar( std::mutex * optionalMutex = nullptr ) { ... if ( nullptr != optionalMutex ) { std::lock_guard<std::mutex> lockScope( *optionalMutex ); foo... } else { foo... } }

编译器gcc 4.9.3无法编译第二个示例并抱怨：error: expected primary-expression before 'lockScope'。 更新： Superlokkus在回答中解释了原因。

但我确实希望避免任何代码重复，因此也避免重复foo。

我的问题：

是否有优雅方法如何实现此问题？不以使用重复foo。我知道，我可以使用lambda函数来分组 foo但我很好奇是否还有其他解决方案。

Answer 1

这个怎么样？

void bar(std::mutex * optionalMutex = nullptr)
{
        auto lockScope = (optionalMutex == nullptr) ? 
                           std::unique_lock<std::mutex>() 
                         : std::unique_lock<std::mutex>(*optionalMutex);
}

说明：您的编译器在使用先前的语句时遇到问题，因为您不能突然改变三元?表达式的类型;即文字0不是std::lock_guard，反之亦然。所以我将两个分支更改为相同的类型，这里std::unique_lock<std::mutex>因为lock_guard没有设计在没有有效互斥锁的情况下使用。但在更简单的情况下，仍然更喜欢std::lock_guard而不是std::unique_lock，因为它会使您的代码更具可读性。

此外，你的陈述对于编译器来说是不可行的，即使语法正确，因为变量lockScope只存在于一个分支中。

Answer 2

你真正拥有的是两个功能，一个锁定，一个不起作用。第一个可以调用第二个：

void bar() {
    // whatever
}

void bar(std::mutex* mtx) {
    std::lock_guard<std::mutex> lockScope(*mtx);
    bar();
}

Answer 3

我只有这个解决方案。使用虚拟mutex对象：

代码是：

bar( std::mutex * optionalMutex = nullptr )
{
   ...
   std::mutex dummyMutex;
   std::lock_guard<std::mutex> lockScope( optionalMutex ? *optionalMutex, dummyMutex );

   foo...     <- NOW foo is protected when optionalMutex was provided
}

Answer 4

这是一个小小的抱怨但你可以通过让调用者传递一个std :: unique_lock来避免传递原始指针：

bar( std::unique_lock<std::mutex> lockScope )
{
    if(lockScope.mutex())
    {
        lockScope.lock();
        //do things
    }
}

这似乎更清晰地表达了界面并减少了滥用的可能性。

Answer 5

实现自己的版本的lock_guard相当简单，该版本需要一个指向互斥量而不是引用的指针。

template <typename MutexT>
class conditional_lock_guard
{
private:

    MutexT* const m_mtx;

public:

    explicit conditional_lock_guard(MutexT* mtx) :
        m_mtx{ mtx }
    {
        if (m_mtx != nullptr)
        {
            m_mtx->lock();
        }
    }

    ~conditional_lock_guard() noexcept
    {
        if (m_mtx != nullptr)
        {
            m_mtx->unlock();
        }
    }

    conditional_lock_guard(const conditional_lock_guard&) = delete;
    conditional_lock_guard& operator=(const conditional_lock_guard&) = delete;

    bool owns_lock() const noexcept
    {
        return m_mtx != nullptr;
    }

    explicit operator bool() const noexcept
    {
        return owns_lock();
    }

    MutexT* mutex() const noexcept
    {
        return m_mtx;
    }
};

Answer 6

Superlockus的答案已经足够好了，但我想知道你为什么不这么简单地写它：

bar( std::mutex * optionalMutex = nullptr )
{
   if (optionalMutex)
      optionalMutex->lock():

   foo...

   if (optionalMutex)
      optionalMutex->unlock():
}

lock_guard和unique_lock很方便但不是唯一的方式。

有条件地使用std :: lock_guard

6 个答案: