Troubles with std::lock_guard<std::mutex> and if constexpr block

Question

There is a class template Foo<T>. And for some specific type, a function should use lock_guard. Here is the example code:

#include <type_traits>
#include <mutex>
#include <vector>

template<typename T> 
class Foo {
public:
    void do_something(int k) {

        if constexpr(std::is_same_v<T, NeedMutexType>) {
            std::lock_guard<std::mutex> lock(mtx_);
        }

        resource_.push_back(k);
        // code for task with resource_ ...
    }

private:
    std::mutex mtx_;
    std::vector<int> resource_;
};

The std::lock_guard will destructed in the end of if constexpr scope. (If it's not true, please correct me.)

To handle this, I can copy the code for task with resource_ below into the if constexpr scope, or just use the raw std::mutex such as mtx_.lock() & mtx_.unlock() instead.

Is there any some ways to handle this with std::lock_guard ? Thanks.

Answer 1

Perhaps std::conditional could come to the rescue here, if you need to do this kind of thing a lot.

template<class Mutex>
struct FakeLockGuard { FakeLockGuard(Mutex&){} };

template<typename T, class Mutex = std::mutex>
using OptionalLock = typename std::conditional<
    std::is_same_v<T, NeedMutexType>,
    std::lock_guard<Mutex>,
    FakeLockGuard<Mutex>>::type;

Here we've defined a do-nothing class template that's constructed the same way as std::lock_guard. We then use that with std::conditional to select either std::lock_guard or FakeLockGuard depending on the result of your type-check.

Now you can use it as follows:

template<typename T> 
class Foo {
public:
    void do_something(int k)
    {
        OptionalLock<T> lock(mtx_);
        resource_.push_back(k);
        // ...
    }

private:
    std::mutex mtx_;
    std::vector<int> resource_;
};

You can easily verify this works by setting a breakpoint in the FakeLockGuard constructor or making it output something.

That's how you can make it all work at compile-time. But I think as you alluded to already, you can simply construct a unique_lock and then conditionally lock it. This has the benefit of being much clearer to whoever has to work with your code. In the end, it's up to whatever you think is most appropriate.

Answer 2

You basically have two different functions:

std::lock_guard<std::mutex> lock(mtx_);
resource_.push_back(k);
// code for task with resource_ ...

resource_.push_back(k);
// code for task with resource_ ...

So you can package the common stuff into a different function:

private:
    void do_something_unlocked(int k) {
        resource_.push_back(k);
        // code for task with resource_ ...
    }
public:
    void do_something(int k) {
        if constexpr (std::is_same_v<T, NeedMutexType>) {
            std::lock_guard lock(mtx_);
            do_something_unlocked(k);
        } else {
            do_something_unlocked(k);
        }
    }

---

The general fix to if constexpr creating its own scope is to put it in a lambda:

void do_something(int k) {
    auto maybe_lock = [&]{
        if constexpr (std::is_same_v<T, NeedMutexType>) {
            return std::lock_guard{mtx_};
        } else {
            return 0;  // Dummy value; no lock needed
        }
    }();
    resource_.push_back(k);
    // code for task with resource_ ...
}

Which is just barely less typing than the helper function, but could be easier to use (especially if you use it multiple times and make a member function auto maybe_lock())

Answer 3

Just construct the lock in the unlocked state then lock it later:

template<typename T> 
class Foo {
public:
    void do_something(int k) {
        std::unique_lock<std::mutex> lock(mutex_, std::defer_lock);
        if constexpr(std::is_same_v<T, NeedMutexType>) {
            lock.lock();
        }

        resource_.push_back(k);
        // code for task with resource_ ...
    }

private:
    std::mutex mtx_;
    std::vector<int> resource_;
}

Note that you'll need to use std::unique_lock for this as std::lock_guard can't be constructed unlocked