C++11std::mutex的使用-创新互联

std::mutex

Mutex 系列类(四种)
- std::mutex，最基本的 Mutex 类
- std::recursive_mutex，递归 Mutex 类
- std::time_mutex，定时 Mutex 类。
- std::recursive_timed_mutex，定时递归 Mutex
Lock 类（两种）
- std::lock_guard，与 Mutex RAII 相关，方便线程对互斥量上锁。
- std::unique_lock，与 Mutex RAII 相关，方便线程对互斥量上锁，但提供了更好的上锁和解锁控制。
其他类型
- std::once_flag（提供一种方式，可以保证其实例绑定的函数，能且仅能被执行一次）
- adopt_lock_t(假设调用方线程已拥有互斥的所有权)
- std::defer_lock_t(不获得互斥的所有权)
- std::try_to_lock_t（尝试获得互斥的所有权而不阻塞）
相关函数
- std::try_lock，尝试同时对多个互斥量上锁。
- std::lock，可以同时对多个互斥量上锁。
- std::call_once，如果多个线程需要同时调用某个函数，call_once 可以保证多个线程对该函数只调用一次。

为罗平等地区用户提供了全套网页设计制作服务，及罗平网站建设行业解决方案。主营业务为成都网站制作、成都网站设计、外贸营销网站建设、罗平网站设计，以传统方式定制建设网站，并提供域名空间备案等一条龙服务，秉承以专业、用心的态度为用户提供真诚的服务。我们深信只要达到每一位用户的要求，就会得到认可，从而选择与我们长期合作。这样，我们也可以走得更远！

Mutex 系列类(四种)

std::mutex，最基本的 Mutex 类

独占互斥量，只能加锁一次
std::mutex 是C++11 中最基本的互斥量，std::mutex 对象提供了独占所有权的特性——即不支持递归地对 std::mutex 对象上锁，而 std::recursive_lock 则可以递归地对互斥量对象上锁。
std::mutex成员函数：
构造函数，std::mutex不允许拷贝构造，也不允许 move 拷贝，最初产生的 mutex 对象是处于 unlocked 状态的。
lock()，调用线程将锁住该互斥量
unlock()，解锁，释放对互斥量的所有权。
try_lock()，尝试锁住互斥量，如果互斥量被其他线程占有，则当前线程也不会被阻塞。

std::recursive_mutex，递归 Mutex 类

递归的独占互斥量，允许同一个线程，同一个互斥量，多次被lock，用法和非递归的一样跟windows的临界区是一样的，但是调用次数是有上限的，效率也低一些
和 std::mutex 不同的是，
std::recursive_mutex 允许同一个线程对互斥量多次上锁（即递归上锁），来获得对互斥量对象的多层所有权，
std::recursive_mutex 释放互斥量时需要调用与该锁层次深度相同次数的 unlock()，可理解为 lock() 次数和 unlock() 次数相同.

std::time_mutex，定时 Mutex 类。

带超时的互斥量,独占互斥量这个就是拿不到锁会等待一段儿时间，但是超过设定时间，就继续执行
std::time_mutex 比 std::mutex 多了两个成员函数，try_lock_for()，try_lock_until()。
template< class Rep, class Period >bool try_lock_for( const
std::chrono::duration& timeout_duration ); 
//  (C++11 起) 
template< class Rep, class Period >bool try_lock_for( const
std::chrono::duration& timeout_duration ); 
//  (C++11 起)
try_lock_for:尝试锁定互斥，若互斥在指定的时限时期中不可用则返回。
try_lock_until:尝试锁定互斥，若直至抵达指定时间点互斥不可用则返回。
参数
timeout_duration - 要阻塞的大时长
返回值
若成功获得锁则为 true ，否则为 false 。
异常
执行期间时钟、时间点或时长可能抛出的异常（标准库提供的时钟、时间点和时长决不抛出）

std::recursive_timed_mutex，定时递归 Mutex

带超时的，递归的，独占互斥量，允许同一个线程，同一个互斥量，多次被lock，用法和非递归的一样

Lock 类（两种）

std::lock_guard，与 Mutex RAII 相关，方便线程对互斥量上锁。

lock_guard功能与std::mutex的lock与unlock功能相同。不同的是，lock_guard析构时会自动解锁，使用时无须unlock。这就需要我们将共享资源的访问封装成尽可能小的函数，避免加锁时间过长。
为了防止在线程使用mutex加锁后异常退出导致死锁的问题，建议使用lock_guard代替mutex.
std::lock_guard类的构造函数禁用拷贝构造，且禁用移动构造。std::lock_guard类除了构造函数和析构函数外没有其它成员函数
注意，lock_guard对象不以任何方式管理互斥对象的生存期:互斥对象的生存期至少要延长到锁它的lock_guard被销毁。

std::unique_lock，与 Mutex RAII 相关，方便线程对互斥量上锁，但提供了更好的上锁和解锁控制。

unique_lock是个类模板，工作中，一般lock_guard(推荐使用)；lock_guard取代了mutex的lock()和unlock();
unique_lock比lock_guard灵活很多，效率上差一点，内存占用多一点。
std::unique_lock可以在构造时传递第二个参数用于管理互斥量，且能传递不同域中互斥量所有权。
unique_lock私有成员为指针 _Mutex /*_Pmtx，指向传递进来的互斥量，lock_guard私有成员为引用_Mutex& _MyMutex，引用传递进的互斥量。这就决定了unique_lock能够实现传递互斥量的功能。
unique_lock的用法比较多，如果对锁的需求比较简单推荐使用lock_guard。当需要超时或者手动解锁等功能，可以考虑使用unique_lock
不同的情况可使用对应的构造创建对象
unique_lock(mutex, adopt_lock_t) //传递被使用过的mutex，且已经被上过锁，通过。无上锁动作，不阻塞。

unique_lock(mutex, defer_lock_t) //传递被使用过的mutex，未被上过锁。无上锁动作，不阻塞。

unique_lock(mutex, try_to_lock_t) //任何状态的mutex。尝试上锁，不阻塞。

unique_lock(_Mutex& _Mtx, const chrono::duration<_Rep, _Period>&
_Rel_time) //在指定时间长内尝试获取传递的mutex的锁返回。若无法获取锁，会阻塞到指定时间长。

unique_lock(mutex_type& m,std::chrono::time_pointconst& absolute_time) //在给定时间点尝试获取传递的mutex锁返回。若无法获取锁，会阻塞到指定时间点。

unique_lock(unique_lock&& _Other)
//将已经创建的unique_lock锁的所有权转移到新的锁。保持之前锁的状态，不阻塞 ```
unique_lock的成员函数
unique_lock除了拥有跟std::mutex一样的三个成员函数意外，还提供release()函数。
release()返回它所管理的mutex对象指针，并释放所有权；也就是说，这个unique_lock和mutex不再有关系。严格区分unlock()与release()的区别，不要混淆。
  std::unique_locksbguard(my_mutex);
      std::mutex *ptx = sbguard.release(); //现在你有责任自己解锁了
      msgRecvQueue.push_back(i);
      ptx->unlock(); //自己负责mutex的unlock了
unique_lock所有权的传递
std::unique_lockstd::mutex sbguard(my_mutex);//所有权概念
std::unique_lockstd::mutex sbguard1(my_mutex);
std::unique_lockstd::mutex sbguard2(sbguard1);//此句是非法的，复制所有权是非法
//sbguard拥有my_mutex的所有权；sbguard可以把自己对mutex(my_mutex)的所有权转移给其他的unique_lock对象；
//所以unique_lock对象这个mutex的所有权是可以转移，但是不能复制。
所有权的传递的方法
方法1 ：std::move()
方法2：return std:: unique_lockstd::mutex

其他类型

std::once_flag（提供一种方式，可以保证其实例绑定的函数，能且仅能被执行一次）
adopt_lock_t(假设调用方线程已拥有互斥的所有权)

Value used as possible argument to the constructor of unique_lock or lock_guard.
objects constructed with adopt_lock do not lock the mutex object on construction, assuming instead that it is already locked by the current thread.
The value is a compile-time constant that carries no state, and is merely used to disambiguate between constructor signatures.
adopt_lock_t is an empty class.

std::defer_lock_t(不获得互斥的所有权)

Value used as possible argument to unique_lock’s constructor.
unique_lock objects constructed with defer_lock do not lock the mutex object automatically on construction, initializing them as not owning a lock.
The value is a compile-time constant that carries no state, and is merely used to disambiguate between constructor signatures.
defer_lock_t is an empty class.

std::try_to_lock_t（尝试获得互斥的所有权而不阻塞）

Value used as possible argument to unique_lock’s constructor.
unique_lock objects constructed with try_to_lock attempt to lock the mutex object by calling its try_lock member instead of its lock member.
The value is a compile-time constant that carries no state, and is merely used to disambiguate between constructor signatures.

C++11std::mutex的使用-创新互联

其他资讯