C++11之lock_guard学习总结和代码实例

std::lock_gurad 是 C++11 中定义的模板类。定义如下：

template<class _Mutex>    class lock_guard    {   // class with destructor that unlocks mutexpublic:    typedef _Mutex mutex_type;    explicit lock_guard(_Mutex& _Mtx)        : _MyMutex(_Mtx)        {   // construct and lock        _MyMutex.lock();        }    lock_guard(_Mutex& _Mtx, adopt_lock_t)        : _MyMutex(_Mtx)        {   // construct but don't lock        }    ~lock_guard() _NOEXCEPT        {   // unlock        _MyMutex.unlock();        }    lock_guard(const lock_guard&) = delete;    lock_guard& operator=(const lock_guard&) = delete;private:    _Mutex& _MyMutex;    };

在 lock_guard 对象构造时，传入的 Mutex 对象(即它所管理的 Mutex 对象)会被当前线程锁住。在lock_guard 对象被析构时，它所管理的 Mutex 对象会自动解锁，由于不需要程序员手动调用 lock 和 unlock 对 Mutex 进行上锁和解锁操作，因此这也是最简单安全的上锁和解锁方式，尤其是在程序抛出异常后先前已被上锁的 Mutex 对象可以正确进行解锁操作，极大地简化了程序员编写与 Mutex 相关的异常处理代码。

代码中
lock_guard(const lock_guard&) = delete;
lock_guard& operator=(const lock_guard&) = delete;
禁用了拷贝构造函数和赋值构造函数.保证了 lock_guard 对象的所有权不会被转移.

代码参考地址,这哥们讲解的很透彻,
http://blog.csdn.net/liuxuejiang158blog/article/details/17241387

代码实例1:使用固定顺序获取锁

#include <mutex>  #include<unistd.h>  #include<thread>  #include<iostream>  using namespace std;  class big_object  {      public:          big_object(int i=0):data(i){}      public:          int data;  };  void swap(big_object& lhs,big_object& rhs)  {      sleep(1);      cout<<"swap()"<<endl;  }  class X  {      private:          big_object some_detail;          mutable std::mutex m;      public:          X(big_object const& sd):some_detail(sd){}          friend void swap(X& lhs, X& rhs)          {              if(&lhs==&rhs)                  return;              std::lock(lhs.m,rhs.m);//C++库会自动生成加锁顺序，即使调用顺序不一致              std::lock_guard<std::mutex> lock_a(lhs.m,std::adopt_lock);//adopt_lock是告诉lock_guard对象mutex已经被上锁，而lock_gurad对象将获得mutex的所有权，这样就可以保证在lock可能出现异常导致没有unlock的情形不会出现，栈对象会在异常抛出后自动析构              std::lock_guard<std::mutex> lock_b(rhs.m,std::adopt_lock);              swap(lhs.some_detail,rhs.some_detail);          }  };  void threadFun(X& one,X& two){      swap(one,two);  }  int main()  {      big_object ten(10),hundred(100);      X one(ten),two(hundred);      thread threadOne(threadFun,ref(one),ref(two));//不同线程有不同的参数调用顺序,ref表示传递的是引用,否则只有线程函数中传引用无效      thread threadTwo(threadFun,ref(two),ref(one));      threadOne.join();      threadTwo.join();      return 0;  }

代码实例2:层次锁
lock hierarchy指的是给每个mutex分配一个标号从而对mutex逻辑排序。限制条件是：当线程已经持有编号比n小的锁时不能再请求标号为n的mutex.

#include <mutex>  #include <stdexcept>  class hierarchical_mutex//可用于lock_guard<hierarchical_mutex>  {      std::mutex internal_mutex;//      unsigned long const hierarchy_value;//mutex所在的层次      unsigned long previous_hierarchy_value;//记录前一个mutex的层次，用于解锁时恢复线程的层次      static thread_local unsigned long this_thread_hierarchy_value;//线程所在的层次，是个线程私有数据      void check_for_hierarchy_violation()//检查当前mutex是否小于线程层次，不是则抛出异常      {          if(this_thread_hierarchy_value <= hierarchy_value)          {              throw std::logic_error("mutex hierarchy violated");          }      }      void update_hierarchy_value()//更新线程的层次      {          previous_hierarchy_value=this_thread_hierarchy_value;//通过previous_hierarchy_value记住线程的层次          this_thread_hierarchy_value=hierarchy_value;//用当前mutex的层次更新线程层次      }  public:      explicit hierarchical_mutex(unsigned long value):          hierarchy_value(value),//mutex层次初始值          previous_hierarchy_value(0)      {}      void lock()//对mutex加锁      {          check_for_hierarchy_violation();//先检查，保证mutex层次小于线程层次          internal_mutex.lock();          update_hierarchy_value();//更新线程层次      }      void unlock()//对mutex解锁      {          this_thread_hierarchy_value=previous_hierarchy_value;//用记录的previous_hierarchy_value恢复线程层次          internal_mutex.unlock();      }      bool try_lock()//尝试加锁，若mutex已被其它上锁则返回false      {          check_for_hierarchy_violation();          if(!internal_mutex.try_lock())              return false;          update_hierarchy_value();          return true;      }  };  thread_local unsigned long      hierarchical_mutex::this_thread_hierarchy_value(ULONG_MAX);//线程层次初始值为最大，保证开始可以对任意mutex上锁