boost库中thread多线程详解2——mutex与lock

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. 读写锁的实现

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

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

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

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

5. 简单示例

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