C++11 std::unique_lock与std::lock_guard区别及多线程应用实例

 1 std::mutex mut;
 2  
 3 void insert_data()
 4 {
 5        std::lock_guard<std::mutex> lk(mut);
 6        queue.push_back(data);
 7 }
 8  
 9 void process_data()
10 {
11        std::unqiue_lock<std::mutex> lk(mut);
12        queue.pop();
13 }

1 explicit lock_guard (mutex_type& m);//必须要传递一个mutex作为构造参数
2 lock_guard (mutex_type& m, adopt_lock_t tag);//tag=adopt_lock表示mutex已经在之前被上锁，这里lock_guard将拥有mutex的所有权
3 lock_guard (const lock_guard&) = delete;//不允许copy constructor

 1 1 unique_lock() noexcept;    //可以构造一个空的unique_lock对象，此时并不拥有任何mutex
 2  
 3 2 explicit unique_lock (mutex_type& m);//拥有mutex，并调用mutex.lock()对其上锁    
 4  
 5 3 unique_lock (mutex_type& m, try_to_lock_t tag);//tag=try_lock表示调用mutex.try_lock()尝试加锁
 6  
 7 4 unique_lock (mutex_type& m, defer_lock_t tag) noexcept;//tag=defer_lock表示不对mutex加锁，只管理mutex，此时mutex应该是没有加锁的
 8  
 9 5 unique_lock (mutex_type& m, adopt_lock_t tag);//tag=adopt_lock表示mutex在此之前已经被上锁，此时unique_locl管理mutex
10  
11 6 template <class Rep, class Period>
12    unique_lock (mutex_type& m, const chrono::duration<Rep,Period>& rel_time);//在一段时间rel_time内尝试对mutex加锁,mutex.try_lock_for(rel_time)
13  
14 7 template <class Clock, class Duration>
15    unique_lock (mutex_type& m, const chrono::time_point<Clock,Duration>& abs_time);//mutex.try_lock_until(abs_time)直到abs_time尝试加锁
16  
17 8 unique_lock (const unique_lock&) = delete;//禁止拷贝构造
18  
19 9 unique_lock (unique_lock&& x);//获得x管理的mutex，此后x不再和mutex相关，x此后相当于一个默认构造的unique_lock,移动构造函数，具备移动语义,movable but not copyable

1 ~unique_lock();//若unique_lock对象拥有管理的mutex的所有权，mutex没有被销毁或者unlock,那么将执行mutex::unlock()解锁，并不销毁mutex对象。
2 mutex_type* mutex() const noexcept;//返回unique_lock管理的mutex指针，但是unique_lock不会放弃对mutex的管理，若unique_lock对mutex上锁了，其有义务对mutex解锁
3 bool owns_lock() const noexcept;//当mutex被unique_lock上锁，且mutex没有解锁或析构，返回真，否则返回false
4 explicit operator bool() const noexcept;//同上

 1 #include <mutex>
 2 #include <thread>
 3 #include <chrono>
 4 #include <iostream>
 5 #include <string>
 6 using namespace std;
 7 struct bank_account//银行账户
 8 {
 9   explicit bank_account(string name, int money)
10   {
11     sName = name;
12     iMoney = money;
13   }
14  
15   string sName;
16   int iMoney;
17   mutex mMutex;//账户都有一个锁mutex
18 };
19 void transfer( bank_account &from, bank_account &to, int amount )//这里缺少一个from==to的条件判断个人觉得
20 {
21   unique_lock<mutex> lock1( from.mMutex, defer_lock );//defer_lock表示延迟加锁，此处只管理mutex
22   unique_lock<mutex> lock2( to.mMutex, defer_lock );
23   lock( lock1, lock2 );//lock一次性锁住多个mutex防止deadlock
24   from.iMoney -= amount;
25   to.iMoney += amount;
26   cout << "Transfer " << amount << " from "<< from.sName << " to " << to.sName << endl;
27 }
28 int main()
29 {
30   bank_account Account1( "User1", 100 );
31   bank_account Account2( "User2", 50 );
32   thread t1( [&](){ transfer( Account1, Account2, 10 ); } );//lambda表达式
33   thread t2( [&](){ transfer( Account2, Account1, 5 ); } );
34   t1.join();
35   t2.join();
36 }

1 lock_guard<mutex> lock1( from.mMutex );
2 lock_guard<mutex> lock2( to.mMutex );

1 lock( from.mMutex, to.mMutex );
2 lock_guard<mutex> lock1( from.mMutex, adopt_lock );//adopt_lock表示mutex已经上锁，lock1将拥有from.mMutex
3 lock_guard<mutex> lock2( to.mMutex, adopt_lock );

 1 #include<mutex>
 2 #include<exception>
 3 #include<iostream>
 4 using namespace std;
 5 int main(){
 6     mutex one,two;
 7     try{
 8         {
 9             lock(one,two);
10             throw 1;
11             cout<<"locking..."<<endl;
12         }
13     }catch(int){
14         cout<<"catch..."<<endl;
15     }
16     if(!one.try_lock()&&!two.try_lock())
17         cout<<"failure"<<endl;
18     else
19         cout<<"success"<<endl;
20     return 0;
21 }

 1 #include<mutex>
 2 #include<iostream>
 3 using namespace std;
 4 mutex m;
 5 unique_lock<mutex> get_lock(){
 6     unique_lock<mutex> lk(m);
 7     cout<<"prepare data..."<<endl;//准备数据
 8     return lk;//移动构造
 9 }
10 int main(){
11     unique_lock<mutex> lk(get_lock());
12     cout<<"process data..."<<endl;//在mutex保护下数据深加工
13     return 0;
14 }