std::recursive_mutex
Defined in header <mutex> |
||
---|---|---|
class recursive_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 eitherlock
ortry_lock
. During this period, the thread may make additional calls tolock
ortry_lock
. The period of ownership ends when the thread makes a matching number of calls tounlock
. - When a thread owns a
recursive_mutex
, all other threads will block (for calls tolock
) or receive afalse
return value (fortry_lock
) if they attempt to claim ownership of therecursive_mutex
. - The maximum number of times that a
recursive_mutex
may be locked is unspecified, but after that number is reached, calls tolock
will throwstd::system_error
and calls totry_lock
will returnfalse
.
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 Mutex and StandardLayoutType.
Member types
Member type | Definition |
---|---|
native_handle_type (not always present) |
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.
#include <iostream> #include <thread> #include <mutex> class X { std::recursive_mutex m; std::string shared; public: void fun1() { std::lock_guard<std::recursive_mutex> lk(m); shared = "fun1"; std::cout << "in fun1, shared variable is now " << shared << '\n'; } void fun2() { 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 here std::cout << "back in fun2, shared variable is " << shared << '\n'; }; }; int main() { X x; std::thread t1(&X::fun1, &x); std::thread t2(&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) |
© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
https://en.cppreference.com/w/cpp/thread/recursive_mutex