Mutexes and lambda functions in c++

Question

When dealing with concurrency problems I often use std::unique_lock<std::mutex> and std::lock_guard<std::mutex>, no problem with both.

I also extended std::mutex to be able to use it as follow:

mutex.protect([](){
    // my protected code here
}) ;

It locks the mutex and releases it around the lambda call.

Is such a similar behavior already implemented inside boost or the standard library?

Answer 1

Boost Thread has this: http://www.boost.org/doc/libs/1_58_0/doc/html/thread/synchronization.html#thread.synchronization.with_lock_guard

You can use it like you'd expect:

std::mutex mx;

boost::with_lock_guard(mx, []{
    // protected stuff
});

It even supports the usual INVOKE semantics:

int foo(int,double) { return 42; }

// ...

int answer = boost::with_lock_guard(mx, foo, 3, 3.14);

Manual Standard Library Only implementation

You can easily add a thing like this yourself:

template <typename M, typename F, typename... Args> 
    auto my_with_lock_guard(M& mx, F&& f, Args&&... args) {
        std::lock_guard<M> lk(mx);
        return std::forward<F>(f)(std::forward<Args>(args)...);
    }

If the standard ever adopts a proposal like this you can easily swap it out.

Answer 2

If all you want to do is protect code in a smaller scope inside a function you don't need to extend mutex by writing your own protect function. You can just do as below, use curly braces to create a local scope, and when the scope is exited the mutex will automatically be unlocked in an exception safe way.

double process_func() { 
// do some stuff
    { //start a new scope block
      std::lock_guard<my_mutex> g; // mutex is locked here.
      []() { } // your lambda that needs to be protected
    } // Mutex is released here.
// do more stuff
} 

Of course this has the disadvantage over your custom function that, it is difficult to maintain. Someone can come later and inject more code without knowing what they are doing.