When to use recursive mutex?

For example when you have function that calls it recursively, and you want to get synchronized access to it:

void foo() {   ... mutex_acquire();   ... foo();   ... mutex_release();}

without a recursive mutex you would have to create an "entry point" function first, and this becomes cumbersome when you have a set of functions that are mutually recursive. Without recursive mutex:

void foo_entry() {   mutex_acquire(); foo(); mutex_release(); }void foo() { ... foo(); ... }

Recursive and non-recursive mutexes have different use cases. No mutex type can easily replace the other. Non-recursive mutexes have less overhead, and recursive mutexes have in some situations useful or even needed semantics and in other situations dangerous or even broken semantics. In most cases, someone can replace any strategy using recursive mutexes with a different safer and more efficient strategy based on the usage of non-recursive mutexes.

• If you just want to exclude other threads from using your mutex protected resource, then you could use any mutex type, but might want to use the non-recursive mutex because of its smaller overhead.
• If you want to call functions recursively, which lock the same mutex, then they either
  • have to use one recursive mutex, or
  • have to unlock and lock the same non-recursive mutex again and again (beware of concurrent threads!) (assuming this is semantically sound, it could still be a performance issue), or
  • have to somehow annotate which mutexes they already locked (simulating recursive ownership/mutexes).
• If you want to lock several mutex-protected objects from a set of such objects, where the sets could have been built by merging, you can choose
  • to use per object exactly one mutex, allowing more threads to work in parallel, or
  • to use per object one reference to any possibly shared recursive mutex, to lower the probability of failing to lock all mutexes together, or
  • to use per object one comparable reference to any possibly shared non-recursive mutex, circumventing the intent to lock multiple times.
• If you want to release a lock in a different thread than it has been locked, then you have to use non-recursive locks (or recursive locks which explicitly allow this instead of throwing exceptions).
• If you want to use synchronization variables, then you need to be able to explicitly unlock the mutex while waiting on any synchronization variable, so that the resource is allowed to be used in other threads. That is only sanely possible with non-recursive mutexes, because recursive mutexes could already have been locked by the caller of the current function.

I encountered the need for a recursive mutex today, and I think it's maybe the simplest example among the posted answers so far:This is a class that exposes two API functions, Process(...) and reset().

public void Process(...){  acquire_mutex(mMutex);  // Heavy processing  ...  reset();  ...  release_mutex(mMutex);}public void reset(){  acquire_mutex(mMutex);  // Reset  ...  release_mutex(mMutex);}

Both functions must not run concurrently because they modify internals of the class, so I wanted to use a mutex.Problem is, Process() calls reset() internally, and it would create a deadlock because mMutex is already acquired.Locking them with a recursive lock instead fixes the problem.