Mutex/Lock with scope/codeblock

Question

I remember seeing it in some conference, but can't find any information on this.

I want something like:

lock(_somelock)
{
    if (_someBool)
        return;

    DoStuff();
} // Implicit unlock

Instead of:

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

DoStuff();
unlock(_somelock);

As you can see the code gets very bloated with multiple early returns. Obviously one could make another function to handle locking/unlocking, but it's a lot nicer no?

Possible with C++11 standard library?

You might want to check [this reference](http://en.cppreference.com/w/cpp/thread). — Some programmer dude, Mar 07 '14 at 09:28

score 6 · Answer 1 · answered Mar 07 '14 at 09:29

6

Yes, you can use a std::lock_guard to wrap a mutex.

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

    if (_someBool)
        return;

    DoStuff();

}

answered Mar 07 '14 at 09:29

Marius Bancila

16,053
9
49
91

score 3 · Answer 2 · answered Mar 07 '14 at 09:29

The standard idiom is to use a guard object whose lifetime encompasses the locked state of the mutex:

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();
}

score 0 · Answer 3 · answered Mar 07 '14 at 10:03

You can simply create an autolock of your own.

Class AutoLock
{
  pthread_mutex_t *mpLockObj;

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

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

use like:

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

  pthread_mutex_t lock;
  LOCK(lock);

  return 0; 
}

Mutex/Lock with scope/codeblock

3 Answers3