1. mutex对象类

mutex类主要有两种：独占式与共享式的互斥量。
▲ 独占式互斥量：
mutex: 独占式的互斥量，是最简单最常用的一种互斥量类型
try_mutex: 它是mutex的同义词，为了与兼容以前的版本而提供
timed_mutex: 它也是独占式的互斥量，但提供超时锁定功能
▲ 递归式互斥量：
recursive_mutex: 递归式互斥量，可以多次锁定，相应地也要多次解锁
recursive_try_mutex: 它是recursive_mutex 的同义词，为了与兼容以前的版本而提供
recursive_timed_mutex: 它也是递归式互斥量，基本功能同recursive_mutex, 但提供超时锁定功能
▲ 共享式互斥量：
shared_mutex: multiple-reader/single-writer 型的共享互斥量(又称读写锁)。
其中mutex有lock和unlock方法，shared_mutex除了提供lock和unlock方法外，还有shared_lock和shared_unlock方法。

2. lock模板类

▲ 独占锁：
boost::unique_lock<T>，其中T可以mutex中的任意一种。
  如果T为mutex，那么boost::unique_lock<boost::mutex>，构造与析构时则分别自动调用lock和unlock方法。
  如果T为shared_mutex，那么boost::unique_lock<boost::shared_mutex>，构造与析构时则分别调用shared_mutex的shared_lock和shared_unlock方法。
注意：scoped_lock也是独占锁，其源代码中定义如下；
  typedef unique_lock<mutex> scoped_lock;
  typedef unique_lock<timed_mutex> scoped_timed_lock;
▲ 共享锁：
boost::shared_lock<T>，其中的T只能是shared_mutex类。
当然还有其他一些锁：lock_guard, upgrade_lock等。

3. 读写锁的实现

[cpp] view plaincopyprint?

 

1. typedef boost::shared_lock<boost::shared_mutex> readLock;  
2. typedef boost::unique_lock<boost::shared_mutex> writeLock;  
3. boost::shared_mutex rwmutex;  
4.   
5. void readOnly()  
6. {  
7.   readLock rdlock(rwmutex);  
8.   // do something  
9. }  
10.   
11. void writeOnly()  
12. {  
13.   writeLock wtlock(rwmutex);  
14.   // do something  
15. }  

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

4. boost::lock_guard<>和boost::unique_lock<>的区别

[cpp] view plaincopyprint?

 

1. boost::mutex m;  
2. void foo( )  
3. {  
4.   boost::lock_guard<boost::mutex> lk(m);  
5.   process(data);  
6. };  
7.   
8. // lock_guard只能像上面这样使用，而unique_lock允许设置超时，推迟锁定lock以及在对象销毁之前unlock。  
9. {  
10.   boost::unique_lock<boost::mutex> lk( m );  
11.   process( data );  
12.   lk.unlock( );  
13.   // do other thing  
14. };  
15.   
16. // 设置锁超时  
17. {  
18.   boost::unique_lock<boost::timed_mutex> lk(m, std::chrono::milliseconds(3)); // 超时3秒  
19.   if(lk)  
20.     process( data );  
21. };  

5. 简单示例

[cpp] view plaincopyprint?

 

1. 1. namespace  
   2. {  
   3.     boost::mutex mutex;  
   4.     boost::shared_mutex shared_mutex;  
   5.   
   6.     void wait(int seconds)  
   7.     {  
   8.         boost::this_thread::sleep(boost::posix_time::seconds(seconds));  
   9.     }  
   10.   
   11.     void threadfun1()  
   12.     {  
   13.         for (int i = 0; i < 5; ++i)  
   14.         {  
   15.             wait(1);  
   16.             mutex.lock();  
   17.             PRINT_DEBUG(i);  
   18.             mutex.unlock();  
   19.         }  
   20.     }  
   21.   
   22.     void threadfun2()  
   23.     {  
   24.         for (int i = 0; i < 5; ++i)  
   25.         {  
   26.             wait(1);  
   27.             boost::lock_guard<boost::mutex> lock(mutex);  
   28.             PRINT_DEBUG(i);  
   29.         }  
   30.     }  
   31.       
   32.     void threadfun3()  
   33.     {  
   34.         for (int i = 0; i < 5; ++i)  
   35.         {  
   36.             wait(1);  
   37.             // unique_lock<boost::mutex> = scoped_lock  
   38.             boost::unique_lock<boost::mutex> lock(mutex);  
   39.             std::cout << lock.owns_lock() << std::endl;  
   40.             PRINT_DEBUG(i);  
   41.         }  
   42.     }  
   43. }  
   44.   
   45. // 1. mutex例子  
   46. void test_thread_syn1()  
   47. {  
   48.     boost::thread t1(&threadfun1);  
   49.     boost::thread t2(&threadfun1);  
   50.   
   51.     t1.join();  
   52.     t2.join();  
   53. }  
   54.   
   55. //  2. lock_guard例子  
   56. void test_thread_syn2()  
   57. {  
   58.     boost::thread t1(&threadfun2);  
   59.     boost::thread t2(&threadfun2);  
   60.   
   61.     t1.join();  
   62.     t2.join();  
   63. }  
   64.   
   65. // 3. scoped_lock例子  
   66. void test_thread_syn3()  
   67. {  
   68.     boost::thread t1(&threadfun3);  
   69.     boost::thread t2(&threadfun3);  
   70.   
   71.     t1.join();  
   72.     t2.join();  
   73. }