std::mutex

Code

refernce：
http://www.cplusplus.com/reference/mutex/unique_lock/unique_lock/
http://blog.csdn.net/liuxuejiang158blog/article/details/17263353

C11的mutex(互斥量) 跟boost的mutex还是存在一些特性区别的

boost 实现的读写锁

• （cpp标准库不支持的）http://permalink.gmane.org/gmane.comp.lib.boost.devel/211180

• Lock模板
  boost::unique_lock，boost::shared_lock，其中unique_lock为独占锁，shared_lock为共享锁。unique_lock中的T可以为mutex类中的任意一种，如果为shared_mutex，那么boost:: unique_lock类的对象构造函数构造时，会自动调用shared_mutex的shared_lock方法，析构函数里，会自动调用shared_mutex的shared_unlock方法。如果是boost:: unique_lock，则分别自动调用lock和unlock方法。
  boost::shared_lock中的T只能是shared_mutex类。

• 读写锁阐述
  对同一个rwmutex，线程可以同时有多个readLock，这些readLock会阻塞任意一个企图获得writeLock的线程，直到所有的readLock对象都析构。如果writeLock首先获得了rwmutex，那么它会阻塞任意一个企图在rwmutex上获得readLock或者writeLock的线程。

• demo

typedef boost::shared_lock<boost::shared_mutex> readLock;
typedef boost:: unique_lock<boost::shared_mutex> writeLock;
boost::shared_mutex  rwmutex;
void readOnly() {
    readLock  rdlock( rwmutex );
    /// do something
}
void writeOnly() {
    writeLock  wtlock( rwmutex );
    /// do something
}

unique_lock

default (1)         unique_lock() noexcept;
locking (2)         explicit unique_lock (mutex_type& m);
try-locking (3)     unique_lock (mutex_type& m, try_to_lock_t tag);
deferred (4)        unique_lock (mutex_type& m, defer_lock_t tag) noexcept;
adopting (5)        unique_lock (mutex_type& m, adopt_lock_t tag);
locking for (6)     template <class Rep, class Period>
                    unique_lock (mutex_type& m, const chrono::duration<Rep,Period>& rel_time);
locking until (7)   template <class Clock, class Duration>
                    unique_lock (mutex_type& m, const chrono::time_point<Clock,Duration>& abs_time);
copy [deleted] (8)  unique_lock (const unique_lock&) = delete;
move (9)            unique_lock (unique_lock&& x);
Construct unique_lock

会导致deadlock的demo

right:

 // unique_lock constructor example
#include <iostream>       // std::cout
#include <thread>         // std::thread
#include <mutex>          // std::mutex, std::lock, std::unique_lock
                          // std::adopt_lock, std::defer_lock
std::mutex foo,bar;
void task_a () {
  std::lock (foo,bar);         // simultaneous lock (prevents deadlock)
  std::unique_lock<std::mutex> lck1 (foo,std::adopt_lock);
  std::unique_lock<std::mutex> lck2 (bar,std::adopt_lock);
  std::cout << "task a\n";
  // (unlocked automatically on destruction of lck1 and lck2)
}
void task_b () {
  // foo.lock(); bar.lock(); // replaced by:
  std::unique_lock<std::mutex> lck1, lck2; 
  //defer_lock表示延迟加锁，此处只管理mutex  
  lck1 = std::unique_lock<std::mutex>(bar,std::defer_lock);
  lck2 = std::unique_lock<std::mutex>(foo,std::defer_lock);
  std::lock (lck1,lck2);       // simultaneous lock (prevents deadlock)
  std::cout << "task b\n";
  // (unlocked automatically on destruction of lck1 and lck2)
}
int main ()
{
  std::thread th1 (task_a);
  std::thread th2 (task_b);
  th1.join();
  th2.join();
  return 0;

error:

lock_guard<mutex> lock1(foo);  
lock_guard<mutex> lock2(bar);  

unique_lock::lock(), unique_lock::unlock()这一组成员函数充分说明了，unique_lock在构造时不必对mutex加锁且可以在后期某个时候对mutex加锁; unique_lock可以在自己实例销毁前调用unique_lock::unlock()提前释放锁，这对于一些分支语句中可能得到性能提升。