Question

我记得在某个会议上看过它，但找不到任何相关信息。

我想要类似的东西：

lock(_somelock)
{
    if (_someBool)
        return;

    DoStuff();
} // Implicit unlock

而不是：

lock(_somelock);
if (_someBool)
{
    unlock(_somelock);
    return;
}

DoStuff();
unlock(_somelock);

正如您所看到的，代码变得非常臃肿，有多个早期返回。显然，人们可以使另一个功能来处理锁定/解锁，但是它没有更好的吗？

可能使用C ++ 11标准库吗？

Answer 1

是的，您可以使用std::lock_guard来包装互斥锁。

{
   std::lock_guard<std::mutex> lock(your_mutex);

    if (_someBool)
        return;

    DoStuff();

}

Answer 2

标准习惯用法是使用一个保护对象，其生命周期包含互斥锁的锁定状态：

std::mutex m;
int shared_data;

// somewhere else

void foo()
{
    int x = compute_something();

    {
        std::lock_guard<std::mutex> guard(m);
        shared_data += x;
    }

    some_extra_work();
}

Answer 3

您只需创建自己的自动锁定。

Class AutoLock
{
  pthread_mutex_t *mpLockObj;

  AutoLock(pthread_mutex_t& mpLockObj)
  {
      mpLockObj = &mpLockObj;
      pthread_mutex_lock(mpLockObj);
  }

  ~AutoLock()
  {
     pthread_mutex_unlock(mpLockObj);
  }
};

使用像：

#define LOCK(obj) AutoLock LocObj(obj);
int main()
{

  pthread_mutex_t lock;
  LOCK(lock);

  return 0; 
}

具有范围/代码块的互斥锁/锁定

3 个答案: