From cppreference.com
classrecursive_mutex;(since C++11)The recursive_mutex class is a synchronization primitive that can be used to protect shared data from being simultaneously accessed by multiple threads.
recursive_mutex offers exclusive, recursive ownership semantics:
A calling thread owns a recursive_mutex for a period of time that starts when it successfully calls either
or
. During this period, the thread may make additional calls to
or
. The period of ownership ends when the thread makes a matching number of calls to
.
When a thread owns a recursive_mutex, all other threads will block (for calls to
) or receive a false return value (for
) if they attempt to claim ownership of the recursive_mutex.
The maximum number of times that a recursive_mutex may be locked is unspecified, but after that number is reached, calls to
will throw
and calls to
will return false.
The behavior of a program is undefined if a recursive_mutex is destroyed while still owned by some thread. The recursive_mutex class satisfies all requirements of
and
.
Member types
Member type Definition native_handle_type(optional*)implementation-defined
Member functions
constructs the mutex
(public member function)
destroys the mutex
(public member function)
operator=
[deleted]
not copy-assignable
(public member function)
Locking
locks the mutex, blocks if the mutex is not available
(public member function)
tries to lock the mutex, returns if the mutex is not available
(public member function)
unlocks the mutex
(public member function)
Native handle
returns the underlying implementation-defined native handle object
(public member function)
Example
One use case for recursive_mutex is protecting shared state in a class whose member functions may call each other.
Run this code
#include<iostream>#include<mutex>#include<thread>classX{std::recursive_mutexm;std::stringshared;public:voidfun1(){std::lock_guard<std::recursive_mutex>lk(m);shared="fun1";std::cout<<"in fun1, shared variable is now "<<shared<<'\n';}voidfun2(){std::lock_guard<std::recursive_mutex>lk(m);shared="fun2";std::cout<<"in fun2, shared variable is now "<<shared<<'\n';fun1();// recursive lock becomes useful herestd::cout<<"back in fun2, shared variable is "<<shared<<'\n';}};intmain(){Xx;std::threadt1(&X::fun1,&x);std::threadt2(&X::fun2,&x);t1.join();t2.join();}Possible output:
in fun1, shared variable is now fun1 in fun2, shared variable is now fun2 in fun1, shared variable is now fun1 back in fun2, shared variable is fun1 See also
(C++11)
provides basic mutual exclusion facility
(class)