C++: Preventing multiple functions from being executed at the same time

Question

I ask this questions as all the mutex documentations I find deal with a single function and I think my case is very common.

My question is whether the following code won't only prevent func1() OR func2() from being executed multiple times in parallel, but whether it would also prevent func1() AND func2() from being executing at the same time?

#include <mutex>

std::mutex my_mutex;

void func1() {
    my_mutex.lock();
    // do something ...
    my_mutex.unlock();
}

void func2() {
    my_mutex.lock();
    // do something ...
    my_mutex.unlock();
}

As I understand many people usually copy code from Stackoverflow, I am adding another version of my sample code, after adding @Al_Bundy's input - using lock_guard, which is destructed when the function ends and thus makes sure your mutex is released when the function ends and the guard is destructed. It is much safer and better practice, as it releases the mutex in any case the function returns or exits, even when it exits because of an exception.

#include <mutex>

std::mutex my_mutex;

void func1() {
    std::lock_guard<std::mutex> locker(my_mutex);
    // do something ...
}

void func2() {
    std::lock_guard<std::mutex> locker(my_mutex);
    // do something ...
}

Answer 1

Both of your functions are locking the same mutex, therefore at most one of them can be executing at any one time.

Mutexes don't care about functions etc. at all. A mutex itself is either locked or unlocked. Any attempt to lock it while it's already locked will block until the mutex becomes unlocked. You're working with one mutex, so as soon as it's locked by any my_mutex.lock() anywhere in your code, all further calls to my_mutex.lock() will block until my_mutex.unlock() is called.

Once that happens, one of the threads blocking inside the lock() call will unblock, acquire (= lock) the mutex, and proceed. The others will remain blocked.