Standard library header  (C++11) (original) (raw)

This header is part of the thread support library.

[edit] Synopsis

namespace std { class mutex; class recursive_mutex; class timed_mutex; class recursive_timed_mutex;   struct defer_lock_t { explicit defer_lock_t() = default; }; struct try_to_lock_t { explicit try_to_lock_t() = default; }; struct adopt_lock_t { explicit adopt_lock_t() = default; };   inline constexpr defer_lock_t defer_lock { }; inline constexpr try_to_lock_t try_to_lock { }; inline constexpr adopt_lock_t adopt_lock { };   template class lock_guard; template<class... MutexTypes> class scoped_lock; template class unique_lock;   template void swap(unique_lock& x, unique_lock& 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); }

[edit] Class std::mutex

namespace std { class mutex { public: constexpr mutex() noexcept; ~mutex();   mutex(const mutex&) = delete; mutex& operator=(const mutex&) = delete;   void lock(); bool try_lock(); void unlock();   using native_handle_type = /* implementation-defined */; native_handle_type native_handle(); }; }

[edit] Class std::recursive_mutex

namespace std { 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();   using native_handle_type = /* implementation-defined */; native_handle_type native_handle(); }; }

[edit] Class std::timed_mutex

namespace std { class timed_mutex { public: timed_mutex(); ~timed_mutex();   timed_mutex(const timed_mutex&) = delete; timed_mutex& operator=(const timed_mutex&) = delete;   void lock(); // blocking 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();   using native_handle_type = /* implementation-defined */; native_handle_type native_handle(); }; }

[edit] Class std::recursive_timed_mutex

namespace std { 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(); // blocking 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();   using native_handle_type = /* implementation-defined */; native_handle_type native_handle(); }; }

[edit] Class template std::lock_guard

namespace std { template class lock_guard { public: using mutex_type = Mutex;   explicit lock_guard(mutex_type& m); lock_guard(mutex_type& m, adopt_lock_t); ~lock_guard();   lock_guard(const lock_guard&) = delete; lock_guard& operator=(const lock_guard&) = delete;   private: mutex_type& pm; // exposition only }; }

[edit] Class template std::scoped_lock

namespace std { 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 }; }

[edit] Class template std::unique_lock

namespace std { template class unique_lock { public: using mutex_type = Mutex;   // 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(const unique_lock&) = delete; unique_lock& operator=(const unique_lock&) = delete;   unique_lock(unique_lock&& u) noexcept; unique_lock& operator=(unique_lock&& u);   // 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 };   template void swap(unique_lock& x, unique_lock& y) noexcept; }

[edit] Class std::once_flag

namespace std { struct once_flag { constexpr once_flag() noexcept;   once_flag(const once_flag&) = delete; once_flag& operator=(const once_flag&) = delete; }; }