Thread in boost library threads 2--mutex and lock

1. Mutex Object class

There are two main types of mutex classes: exclusive and shared mutex.
▲ Exclusive Mutex Amount:
Mutex: Exclusive mutex, which is the simplest and most common type of mutex
Try_mutex: It is a synonym for a mutex, provided for compatibility with previous versions
Timed_mutex: It is also an exclusive mutex, but provides a timeout lock feature
▲ Recursive mutual-exclusion amount:
Recursive_mutex: Recursive mutex, can be locked multiple times, corresponding to the number of unlocked
Recursive_try_mutex: It is a synonym for Recursive_mutex, provided for compatibility with previous versions
Recursive_timed_mutex: It is also recursive mutex, basic ability with Recursive_mutex, but provides time-out lock function
▲ Shared Mutex:
Shared_mutex:multiple-reader/single-writer shared Mutex (also known as read-write lock).
The mutex has a lock and unlock method, Shared_mutex in addition to providing the lock and unlock methods, there are Shared_lock and Shared_unlock methods.

2. Lock template class

▲ Exclusive Lock:
Boost::unique_lock<t>, where T can be any of a mutex.
If T is a mutex, then Boost::unique_lock<boost::mutex>, and the lock and unlock methods are automatically called when you construct and refactor.
If T is Shared_mutex, then Boost::unique_lock<boost::shared_mutex>, and the Shared_lock and shared_ of Shared_mutex are called respectively when constructing and destruction Unlock method.
Note: Scoped_lock is also an exclusive lock, which is defined in the source code as follows;
typedef unique_lock<mutex> Scoped_lock;
typedef unique_lock<timed_mutex> Scoped_timed_lock;
▲ Shared Lock:
Boost::shared_lock<t>, where T can only be the Shared_mutex class.
Of course there are some other locks: lock_guard, upgrade_lock and so on.

3. Implementation of read-write lock [CPP]View Plaincopyprint?

2. typedef boost::shared_lock<boost::shared_mutex> Readlock;
4. typedef boost::unique_lock<boost::shared_mutex> Writelock;
6. Boost::shared_mutex Rwmutex;
10. void ReadOnly ()
12. {
14. Readlock Rdlock (Rwmutex);
16. //Do something
18. }
22. void WriteOnly ()
24. {
26. Writelock Wtlock (Rwmutex);
28. //Do something
30. }

For the same Rwmutex, threads can have multiple readlock at the same time, and these readlock block any thread that attempts to acquire Writelock until all Readlock objects are refactored. If Writelock first obtains the Rwmutex, it blocks any thread that attempts to gain Readlock or Writelock on Rwmutex.

4. The difference between boost::lock_guard<> and boost::unique_lock<> [CPP]View Plaincopyprint?

2. Boost::mutex m;
4. void Foo ()
6. {
8. Boost::lock_guard<boost::mutex> LK (m);
10. Process (data);
12. };
16. Lock_guard can only be used as above, while Unique_lock allows setting timeouts, delaying locking lock, and unlock before objects are destroyed.
18. {
20. Boost::unique_lock<boost::mutex> LK (m);
22. Process (data);
24. Lk.unlock ();
26. // do other thing
28. };
32. Set lock timeout
34. {
36. Boost::unique_lock<boost::timed_mutex> lk (M, Std::chrono::milliseconds (3)); //Timeout 3 seconds
38. if (LK)
40. Process (data);
42. };

5. Simple example [CPP]View Plaincopyprint?

2. Namespace
4. {
6. Boost::mutex Mutex;
8. Boost::shared_mutex Shared_mutex;
12. void Wait (int seconds)
14. {
16. Boost::this_thread::sleep (boost::p osix_time::seconds (seconds));
18. }
22. void Threadfun1 ()
24. {
26. For (int i = 0; i < 5; ++i)
28. {
30. Wait (1);
32. Mutex.lock ();
34. Print_debug (i);
36. Mutex.unlock ();
38. }
40. }
44. void threadfun2 ()
46. {
48. For (int i = 0; i < 5; ++i)
50. {
52. Wait (1);
54. Boost::lock_guard<boost::mutex> lock (mutex);
56. Print_debug (i);
58. }
60. }
64. void Threadfun3 ()
66. {
68. For (int i = 0; i < 5; ++i)
70. {
72. Wait (1);
74. //unique_lock<boost::mutex> = Scoped_lock
76. Boost::unique_lock<boost::mutex> lock (mutex);
78. Std::cout << lock.owns_lock () << Std::endl;
80. Print_debug (i);
82. }
84. }
86. }
90. 1. Mutex examples
92. void Test_thread_syn1 ()
94. {
96. Boost::thread T1 (&THREADFUN1);
98. Boost::thread T2 (&THREADFUN1);
102. T1.join ();
104. T2.join ();
106. }
110. 2. Lock_guard Example
112. void Test_thread_syn2 ()
114. {
116. Boost::thread T1 (&threadfun2);
118. Boost::thread T2 (&THREADFUN2);
122. T1.join ();
124. T2.join ();
126. }
130. 3. scoped_lock Example
132. void Test_thread_syn3 ()
134. {
136. Boost::thread T1 (&THREADFUN3);
138. Boost::thread T2 (&THREADFUN3);
142. T1.join ();
144. T2.join ();
146. }

Thread in boost library threads 2--mutex and lock