标准库标头 <mutex> (C++11)
来自cppreference.com
此头文件是线程支持库的一部分。
类 | ||
(C++11) | 提供基本互斥设施 (类) | |
(C++11) | 提供互斥设施，实现有时限锁定 (类) | |
(C++11) | 提供能被同一线程递归锁定的互斥设施 (类) | |
(C++11) | 提供能被同一线程递归锁定的互斥设施，并实现有时限锁定 (类) | |
(C++11) | 实现严格基于作用域的互斥体所有权包装器 (类模板) | |
(C++11) | 实现可移动的互斥体所有权包装器 (类模板) | |
(C++17) | 用于多个互斥体的免死锁 RAII 封装器 (类模板) | |
(C++11) | 确保 call_once 只调用函数一次的帮助对象 (类) | |
函数 | ||
(C++11) | 尝试通过重复调用 try_lock 获得互斥体的所有权 (函数模板) | |
(C++11) | 锁定指定的互斥体，若任何一个不可用则阻塞 (函数模板) | |
(C++11) | 仅调用函数一次，即使从多个线程调用 (函数模板) | |
(C++11) | 特化 std::swap 算法 (函数模板) | |
标签 | ||
| 用于指定锁定策略的标签 (标签) | ||
[编辑]概要
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;}; inlineconstexpr defer_lock_t defer_lock {};inlineconstexpr try_to_lock_t try_to_lock {};inlineconstexpr adopt_lock_t adopt_lock {}; template<class Mutex>class lock_guard;template<class... MutexTypes>class scoped_lock;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);}
[编辑]类 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 =/* 由实现定义 */; native_handle_type native_handle();};}
[编辑]类 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 =/* 由实现定义 */; native_handle_type native_handle();};}
[编辑]类 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();// 阻塞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 =/* 由实现定义 */; native_handle_type native_handle();};}
[编辑]类 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();// 阻塞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 =/* 由实现定义 */; native_handle_type native_handle();};}
[编辑]类模板 std::lock_guard
namespace std {template<class Mutex>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;// 仅用于阐释};}
[编辑]类模板 std::scoped_lock
namespace std {template<class... MutexTypes>class scoped_lock {public:using mutex_type = Mutex;// 若 MutexTypes... 仅由单个类型 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;// 仅用于阐释};}
[编辑]类模板 std::unique_lock
namespace std {template<class Mutex>class unique_lock {public:using mutex_type = Mutex; // 构造/复制/销毁 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); // 锁定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(); // 修改器void swap(unique_lock& u)noexcept; mutex_type* release()noexcept; // 观察器bool owns_lock()constnoexcept;explicit operator bool()constnoexcept; mutex_type* mutex()constnoexcept; private: mutex_type* pm;// 仅用于阐释bool owns;// 仅用于阐释}; template<class Mutex>void swap(unique_lock<Mutex>& x, unique_lock<Mutex>& y)noexcept;}
[编辑]类 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;};}
