is it safe to use the same mutex with lock_gard and without it in other parts of code

Question

I have the namespace below which func1 and func2 will be called from diffrent threads.

#include<thread>
namespace test{

    std::mutex mu;

    void func1(){
        std::lock_guard<mutex>lock(mu);
       //the whole function needs to be protected
    }

    void func2() {
        mu.lock();
        //some code that should not be executed when func1 is executed
        mu.unlock();
        //some other code
    }
}

is it deadlock safe to use this mutex (once with lock_guard and outside of it ) to protect these critical sections ? if not how to achieve this logic?

Answer 1

Yes, you can effectively mix and match different guard instances (e.g. lock_guard, unique_lock, etc...) with std::mutex in different functions. One case I run into occassionally is when I want to use std::lock_guard for most methods, but usage of std::condition_variable expects a std::unique_lock for its wait method.

To elaborate on what Oblivion said, I typically introduce a new scope block within a function so that usage of std::lock_guard is consistent. Example:

void func2() {

    {  // ENTER LOCK
        lock_guard<std::mutex> lck;

       //some code that should not be executed when func1 is executed

    } // EXIT LOCK

    // some other (thread safe) code 
}

The advantage of the using the above pattern is that if anything throws an exception within the critical section of code that is under a lock, the destructor of lck will still be invoked and hence, unlock the mutex.