Standard library header <mutex>
This header is part of the thread support library.
Classes | |
(C++11) |
provides basic mutual exclusion facility (class) |
(C++11) |
provides mutual exclusion facility which implements locking with a timeout (class) |
(C++11) |
provides mutual exclusion facility which can be locked recursively by the same thread (class) |
(C++11) |
provides mutual exclusion facility which can be locked recursively by the same thread and implements locking with a timeout (class) |
(C++11) |
implements a strictly scope-based mutex ownership wrapper (class template) |
(C++11) |
implements movable mutex ownership wrapper (class template) |
(C++17) |
deadlock-avoiding RAII wrapper for multiple mutexes (class template) |
(C++11)(C++11)(C++11) |
tag type used to specify locking strategy (class) |
(C++11)(C++11)(C++11) |
tag constants used to specify locking strategy (constant) |
(C++11) |
helper object to ensure that call_once invokes the function only once (class) |
Functions | |
(C++11) |
attempts to obtain ownership of mutexes via repeated calls to try_lock (function template) |
(C++11) |
locks specified mutexes, blocks if any are unavailable (function template) |
(C++11) |
invokes a function only once even if called from multiple threads (function template) |
(C++11) |
specialization of std::swap for unique_lock (function template) |
Synopsis
namespace std { class mutex; class recursive_mutex; class timed_mutex; class recursive_timed_mutex; struct defer_lock_t { explicit defer_lock_t() = default; }; inline constexpr defer_lock_t defer_lock { }; struct try_to_lock_t { explicit try_to_lock_t() = default; }; inline constexpr try_to_lock_t try_to_lock { }; struct adopt_lock_t { explicit adopt_lock_t() = default; }; inline constexpr adopt_lock_t adopt_lock { }; template <class Mutex> class lock_guard; template <class Mutex> class unique_lock; template <class Mutex> void swap(unique_lock<Mutex>& x, unique_lock<Mutex>& y) noexcept; template <class L1, class L2, class... L3> int try_lock(L1&, L2&, L3&...); template <class L1, class L2, class... L3> void lock(L1&, L2&, L3&...); struct once_flag; template<class Callable, class ...Args> void call_once(once_flag& flag, Callable func, Args&&... args); }
Class std::mutex
class mutex { public: constexpr mutex() noexcept; ~mutex(); mutex(const mutex&) = delete; mutex& operator=(const mutex&) = delete; void lock(); bool try_lock(); void unlock(); typedef /*implementation-defined*/ native_handle_type; native_handle_type native_handle(); };
Class std::recursive_mutex
class recursive_mutex { public: recursive_mutex(); ~recursive_mutex(); recursive_mutex(const recursive_mutex&) = delete; recursive_mutex& operator=(const recursive_mutex&) = delete; void lock(); bool try_lock() noexcept; void unlock(); typedef /*implementation-defined*/ native_handle_type; native_handle_type native_handle(); };
Class std::timed_mutex
class timed_mutex { public: timed_mutex(); ~timed_mutex(); timed_mutex(const timed_mutex&) = delete; timed_mutex& operator=(const timed_mutex&) = delete; void lock(); bool try_lock(); template <class Rep, class Period> bool try_lock_for(const chrono::duration<Rep, Period>& rel_time); template <class Clock, class Duration> bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time); void unlock(); typedef /*implementation-defined*/ native_handle_type; native_handle_type native_handle(); };
Class std::recursive_timed_mutex
class recursive_timed_mutex { public: recursive_timed_mutex(); ~recursive_timed_mutex(); recursive_timed_mutex(const recursive_timed_mutex&) = delete; recursive_timed_mutex& operator=(const recursive_timed_mutex&) = delete; void lock(); bool try_lock() noexcept; template <class Rep, class Period> bool try_lock_for(const chrono::duration<Rep, Period>& rel_time); template <class Clock, class Duration> bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time); void unlock(); typedef /*implementation-defined*/ native_handle_type; native_handle_type native_handle(); };
Class std::lock_guard
template <class Mutex> class lock_guard { public: typedef Mutex mutex_type; explicit lock_guard(mutex_type& m); lock_guard(mutex_type& m, adopt_lock_t); ~lock_guard(); lock_guard(lock_guard const&) = delete; lock_guard& operator=(lock_guard const&) = delete; private: mutex_type& pm; // exposition only };
Class std::scoped_lock
template<class... MutexTypes> class scoped_lock { public: using mutex_type = Mutex; // If MutexTypes... consists of the single type Mutex explicit scoped_lock(MutexTypes&... m); explicit scoped_lock(adopt_lock_t, MutexTypes&... m); ~scoped_lock(); scoped_lock(const scoped_lock&) = delete; scoped_lock& operator=(const scoped_lock&) = delete; private: tuple<MutexTypes&...> pm; // exposition only };
Class std::unique_lock
template <class Mutex> class unique_lock { public: typedef Mutex mutex_type; // construct/copy/destroy: unique_lock() noexcept; explicit unique_lock(mutex_type& m); unique_lock(mutex_type& m, defer_lock_t) noexcept; unique_lock(mutex_type& m, try_to_lock_t); unique_lock(mutex_type& m, adopt_lock_t); template <class Clock, class Duration> unique_lock(mutex_type& m, const chrono::time_point<Clock, Duration>& abs_time); template <class Rep, class Period> unique_lock(mutex_type& m, const chrono::duration<Rep, Period>& rel_time); ~unique_lock(); unique_lock(unique_lock const&) = delete; unique_lock& operator=(unique_lock const&) = delete; unique_lock(unique_lock&& u) noexcept; unique_lock& operator=(unique_lock&& u) noexcept; // locking: void lock(); bool try_lock(); template <class Rep, class Period> bool try_lock_for(const chrono::duration<Rep, Period>& rel_time); template <class Clock, class Duration> bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time); void unlock(); // modifiers: void swap(unique_lock& u) noexcept; mutex_type *release() noexcept; // observers: bool owns_lock() const noexcept; explicit operator bool () const noexcept; mutex_type* mutex() const noexcept; private: mutex_type *pm; // exposition only bool owns; // exposition only };
Class std::once_flag
struct once_flag { constexpr once_flag() noexcept; once_flag(const once_flag&) = delete; once_flag& operator=(const once_flag&) = delete; };