理解线程同步

线程同步是指多线程通过特定的东西（如互斥量）来控制线程之间的执行顺序(同步）
也可以说是在线程之间通过同步建立起执行顺序的关系，如果没有同步那线程之间是各自运行各自的

 

线程同步有三种常用的机制: 互斥量(mutex), 读写锁(rwlock)和条件变量(cond).

互斥量

    互斥量从本质上说就是一把锁, 提供对共享资源的保护访问.

1. 初始化:

    在Linux下, 线程的互斥量数据类型是pthread_mutex_t. 在使用前, 要对它进行初始化:

对于静态分配的互斥量, 可以把它设置为PTHREAD_MUTEX_INITIALIZER, 或者调用pthread_mutex_init.

对于动态分配的互斥量, 在申请内存(malloc)之后, 通过pthread_mutex_init进行初始化, 并且在释放内存(free)前需要调用pthread_mutex_destroy.

原型:
int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restric attr);
int pthread_mutex_destroy(pthread_mutex_t *mutex);
头文件: <pthread.h>
返回值: 成功则返回0, 出错则返回错误编号.
说明: 如果使用默认的属性初始化互斥量, 只需把attr设为NULL. 其他值在以后讲解.
2. 互斥操作:

    对共享资源的访问, 要对互斥量进行加锁, 如果互斥量已经上了锁, 调用线程会阻塞, 直到互斥量被解锁. 在完成了对共享资源的访问后, 要对互斥量进行解锁.

首先说一下加锁函数:

头文件: <pthread.h>
原型:
int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_trylock(pthread_mutex_t *mutex);
返回值: 成功则返回0, 出错则返回错误编号.
说 明: 具体说一下trylock函数, 这个函数是非阻塞调用模式, 也就是说, 如果互斥量没被锁住, trylock函数将把互斥量加锁, 并获得对共享资源的访问权限; 如果互斥量被锁住了, trylock函数将不会阻塞等待而直接返回EBUSY, 表示共享资源处于忙状态.
再说一下解所函数:

头文件: <pthread.h>
原型: int pthread_mutex_unlock(pthread_mutex_t *mutex);
返回值: 成功则返回0, 出错则返回错误编号.
3. 死锁:

    死锁主要发生在有多个依赖锁存在时, 会在一个线程试图以与另一个线程相反顺序锁住互斥量时发生. 如何避免死锁是使用互斥量应该格外注意的东西.

    总体来讲, 有几个不成文的基本原则:

对共享资源操作前一定要获得锁.
完成操作以后一定要释放锁.
尽量短时间地占用锁.
如果有多锁, 如获得顺序是ABC连环扣, 释放顺序也应该是ABC.
线程错误返回时应该释放它所获得的锁.

1. ifndef __TCMUTEX_H__
   
2. #define __TCMUTEX_H__
   
3. 
   
4. #if !defined(AFX_MUTEX_H__5B26703E_B4A3_4247_B78C_0A5FD39BD73A__INCLUDED_)
   
5. #define AFX_MUTEX_H__5B26703E_B4A3_4247_B78C_0A5FD39BD73A__INCLUDED_
   
6. 
   
7. #include <pthread.h>
   
8. 
   
9. class TCMutex
   
10. {
    
11. public:
    
12.     TCMutex();
    
13.     virtual ~TCMutex();
    
14.     /**    @brief    锁*/
    
15.     void Lock();
    
16.     /**    @brief    解锁*/
    
17.     void UnLock();
    
18. 
    
19.     bool IsLocked()
    
20.     {
    
21.         return m_lock;
    
22.     }
    
23. 
    
24. #ifndef __WIN32__
    
25.     pthread_mutex_t* GetMutex()
    
26.     {
    
27.         return & m_mutex;
    
28.     }    
    
29. #else
    
30.     CRITICAL_SECTION * GetMutex()
    
31.     {
    
32.         return & m_singlelock;
    
33.     }
    
34. #endif
    
35. 
    
36. private:
    
37. 
    
38. #ifndef __WIN32__
    
39.     pthread_mutex_t m_mutex;
    
40.     pthread_mutexattr_t m_attr;
    
41. #else
    
42.     CRITICAL_SECTION m_singlelock;
    
43. #endif
    
44. 
    
45.     bool m_lock;
    
46. };
    
47. #endif

1. #ifndef FALSE
   
2. #define FALSE 0
   
3. #endif
   
4. 
   
5. #ifndef TRUE
   
6. #define TRUE 1
   
7. #endif
   
8. 
   
9. /** @file    TCMutex.cpp
   
10. *    @brief    互斥类源码文件
    
11. *    @version 1.0
    
12. *    @date 2008-12-21*/
    
13. 
    
14. TCMutex::TCMutex()
    
15. {
    
16. #ifndef __WIN32__
    
17.     pthread_mutexattr_init( & m_attr );
    
18. #ifdef __LINUX__
    
19.     pthread_mutexattr_settype(& m_attr,PTHREAD_MUTEX_RECURSIVE_NP);
    
20. #else
    
21.     pthread_mutexattr_settype(& m_attr,PTHREAD_MUTEX_RECURSIVE);    
    
22. #endif    
    
23.     pthread_mutex_init( & m_mutex, & m_attr);
    
24. #else
    
25.     InitializeCriticalSection( &m_singlelock );
    
26. #endif    
    
27.     m_lock = false;
    
28. }
    
29. 
    
30. TCMutex::~TCMutex()
    
31. {
    
32. #ifndef __WIN32__
    
33.     pthread_mutex_destroy( &m_mutex );
    
34. #else
    
35.     DeleteCriticalSection( &m_singlelock );
    
36. #endif
    
37. }
    
38. 
    
39. 
    
40. void TCMutex::Lock()
    
41. {
    
42. #ifndef __WIN32__
    
43.     pthread_mutex_lock( &m_mutex );
    
44.     //if( pthread_mutex_lock(&m_mutex ) < 0 )
    
45.     //{
    
46.     //    throw TCException("Lock() exception!");
    
47.     //}
    
48. #else
    
49.     EnterCriticalSection( &m_singlelock );
    
50. #endif
    
51.     m_lock = true;
    
52. }
    
53. 
    
54. void TCMutex::UnLock()
    
55. {
    
56. #ifndef __WIN32__
    
57.     pthread_mutex_unlock( &m_mutex );
    
58.     //if( pthread_mutex_unlock(&m_mutex ) < 0 )
    
59.     //{
    
60.     //    throw TCException("UnLock() exception!");
    
61.     //}
    
62. #else
    
63.     LeaveCriticalSection( &m_singlelock );
    
64. #endif
    
65.     m_lock = false;
    
66. }

读写锁

    在线程同步系列的第一篇文章里已经说过, 读写锁是因为有3种状态, 所以可以有更高的并行性.

1. 特性:

    一次只有一个线程可以占有写模式的读写锁, 但是可以有多个线程同时占有读模式的读写锁. 正是因为这个特性,

当读写锁是写加锁状态时, 在这个锁被解锁之前, 所有试图对这个锁加锁的线程都会被阻塞.
当读写锁在读加锁状态时, 所有试图以读模式对它进行加锁的线程都可以得到访问权, 但是如果线程希望以写模式对此锁进行加锁, 它必须阻塞直到所有的线程释放锁.
通常, 当读写锁处于读模式锁住状态时, 如果有另外线程试图以写模式加锁, 读写锁通常会阻塞随后的读模式锁请求, 这样可以避免读模式锁长期占用, 而等待的写模式锁请求长期阻塞.
2. 适用性:

    读写锁适合于对数据结构的读次数比写次数多得多的情况. 因为, 读模式锁定时可以共享, 以写模式锁住时意味着独占, 所以读写锁又叫共享-独占锁.

3. 初始化和销毁:

#include <pthread.h>

int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock, const pthread_rwlockattr_t *restrict attr);
int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);

成功则返回0, 出错则返回错误编号.
同互斥量以上, 在释放读写锁占用的内存之前, 需要先通过pthread_rwlock_destroy对读写锁进行清理工作, 释放由init分配的资源.

4. 读和写:

#include <pthread.h>

int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);

成功则返回0, 出错则返回错误编号.
这3个函数分别实现获取读锁, 获取写锁和释放锁的操作. 获取锁的两个函数是阻塞操作, 同样, 非阻塞的函数为:
#include <pthread.h>

int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);

成功则返回0, 出错则返回错误编号.
非阻塞的获取锁操作, 如果可以获取则返回0, 否则返回错误的EBUSY.

1. ifndef __TCRWLOCK_H__
   
2. #define __TCRWLOCK_H__
   
3. 
   
4. #if !defined(AFX_MUTEX_H__5B26703E_B4A3_4247_B78C_0A5FD39BD73A__INCLUDED_)
   
5. #define AFX_MUTEX_H__5B26703E_B4A3_4247_B78C_0A5FD39BD73A__INCLUDED_
   
6. 
   
7. #include <pthread.h>
   
8. 
   
9. #ifdef __WIN32__
   
10. 
    
11. typedef struct _RWLock
    
12. {
    
13.     HANDLE    hMutex;
    
14.     HANDLE    hDataLock;
    
15.     int        nReaderCount;
    
16. } RWLock;
    
17. 
    
18. #endif
    
19. 
    
20. class TCRWLock
    
21. {
    
22. public:
    
23.     TCRWLock();
    
24.     ~TCRWLock();
    
25. 
    
26.     bool ReadLock(void);//请求读操作锁,请求不成功则阻塞
    
27.     bool ReleaseReadLock(void);//释放读操作锁
    
28. 
    
29.     bool WriteLock(void);//请求写操作锁,请求不成功则阻塞
    
30.     bool ReleaseWriteLock(void);//释放写操作锁
    
31. 
    
32. private:
    
33. #ifdef __WIN32__
    
34.     bool MyWaitForSingleObject(HANDLE hObject);
    
35. #else
    
36.     bool MyWaitForSingleObject(void * hObject);
    
37. #endif
    
38.     bool InitRWLock();
    
39.     bool DestroyRWLock();
    
40. private:
    
41. 
    
42. #ifdef __WIN32__
    
43.     RWLock    m_RWLock; //读写锁
    
44. #else
    
45.     pthread_rwlock_t m_RWLock;
    
46. #endif
    
47. 
    
48. };
    
49. 
    
50. typedef class TCMutex CMyMutex;
    
51. typedef class TCRWLock CRWLock;
    
52. 
    
53. 
    
54. #endif //!defined(AFX_MUTEX_H__5B26703E_B4A3_4247_B78C_0A5FD39BD73A__INCLUDED_)

1. //读写锁
   
2. 
   
3. //完成读写锁初始化
   
4. TCRWLock::TCRWLock()
   
5. {
   
6.     if(!InitRWLock())
   
7.     {
   
8.         throw TCException("Init RwLock Error!");
   
9.     }
   
10. }
    
11. 
    
12. TCRWLock::~TCRWLock()
    
13. {
    
14.     DestroyRWLock();
    
15. }
    
16. 
    
17. #ifdef __WIN32__
    
18. bool TCRWLock::MyWaitForSingleObject(HANDLE hObject)
    
19. #else
    
20. bool TCRWLock::MyWaitForSingleObject(void* hObject)
    
21. #endif
    
22. {
    
23. #ifdef __WIN32__
    
24.     DWORD result;
    
25.     result = WaitForSingleObject(hObject, INFINITE);
    
26. 
    
27.     return (result == WAIT_OBJECT_0);
    
28. #else
    
29.     return true;
    
30. #endif
    
31. }
    
32. 
    
33. bool TCRWLock::InitRWLock()
    
34. {
    
35. #ifdef __WIN32__
    
36.     m_RWLock.nReaderCount = 0;
    
37.     m_RWLock.hDataLock = CreateSemaphore(NULL, 1, 1,NULL);
    
38. 
    
39.     if (m_RWLock.hDataLock== NULL)
    
40.     {
    
41.         return false;
    
42.     }
    
43. 
    
44.     m_RWLock.hMutex = CreateMutex(NULL,FALSE, NULL);
    
45. 
    
46.     if (m_RWLock.hMutex== NULL)
    
47.     {
    
48.         CloseHandle(m_RWLock.hDataLock);
    
49.         return false;
    
50.     }
    
51. 
    
52.     return true;
    
53. #else
    
54.     
    
55.     if( pthread_rwlock_init(&m_RWLock,NULL) != 0 )
    
56.     {
    
57.         throw TCException("TCRWLock::InitRWLock() exception!");
    
58.     }
    
59. 
    
60.     return true;
    
61. #endif
    
62. }
    
63. 
    
64. bool TCRWLock::DestroyRWLock()
    
65. {
    
66. #ifdef __WIN32__
    
67.     DWORD result = WaitForSingleObject(m_RWLock.hDataLock, INFINITE);
    
68. 
    
69.     if (result!= WAIT_OBJECT_0)
    
70.     {
    
71.         return false;
    
72.     }
    
73. 
    
74.     CloseHandle(m_RWLock.hMutex);
    
75.     CloseHandle(m_RWLock.hDataLock);
    
76. 
    
77.     return true;
    
78. #else
    
79.     pthread_rwlock_destroy(&m_RWLock);
    
80. 
    
81.     return true;
    
82. #endif
    
83. }
    
84. 
    
85. bool TCRWLock::ReadLock()
    
86. {
    
87. #ifdef __WIN32__
    
88.     bool result = TRUE;
    
89. 
    
90.     if (MyWaitForSingleObject(m_RWLock.hMutex)== FALSE)
    
91.     {
    
92.         return FALSE;
    
93.     }
    
94. 
    
95.     ++ m_RWLock.nReaderCount;
    
96. 
    
97.     if(m_RWLock.nReaderCount== 1)
    
98.     {
    
99.         result = MyWaitForSingleObject(m_RWLock.hDataLock);
    
100.     }
     
101. 
     
102.     ReleaseMutex(m_RWLock.hMutex);
     
103. 
     
104.     return result;
     
105. #else
     
106.     if (pthread_rwlock_rdlock(&m_RWLock)!= 0)
     
107.     {
     
108.         throw TCException("RLock() exception!");
     
109.     }
     
110. 
     
111.     return true;
     
112. #endif
     
113. }
     
114. 
     
115. bool TCRWLock::ReleaseReadLock()
     
116. {
     
117. #ifdef __WIN32__
     
118.     LONG lPrevCount;
     
119.     int result = TRUE;
     
120. 
     
121.     if (MyWaitForSingleObject(m_RWLock.hMutex)== FALSE)
     
122.     {
     
123.         return false;
     
124.     }
     
125. 
     
126.     --m_RWLock.nReaderCount;
     
127. 
     
128.     if (m_RWLock.nReaderCount== 0)
     
129.     {
     
130.         result = ReleaseSemaphore(m_RWLock.hDataLock, 1,&lPrevCount);
     
131.     }
     
132. 
     
133.     ReleaseMutex(m_RWLock.hMutex);
     
134. 
     
135.     return result;
     
136. #else
     
137.     if (pthread_rwlock_unlock(&m_RWLock)!= 0)
     
138.     {
     
139.         throw TCException("TCRWLock::ReleaseReadLock() exception!");
     
140.     }
     
141. 
     
142.     return true;
     
143. #endif
     
144. }
     
145. 
     
146. bool TCRWLock::WriteLock()
     
147. {
     
148. #ifdef __WIN32__
     
149.     return MyWaitForSingleObject(m_RWLock.hDataLock);
     
150. #else
     
151.     if (pthread_rwlock_wrlock(&m_RWLock)!= 0)
     
152.     {
     
153.         throw TCException("TCRWLock::WLock() exception!");
     
154.     }
     
155.     return true;
     
156. #endif
     
157. }
     
158. 
     
159. 
     
160. bool TCRWLock::ReleaseWriteLock()
     
161. {
     
162. #ifdef __WIN32__
     
163.     int result = TRUE;
     
164.     LONG lPrevCount;
     
165. 
     
166.     result = ReleaseSemaphore(m_RWLock.hDataLock, 1,&lPrevCount);
     
167. 
     
168.     if (lPrevCount!= 0)
     
169.     {
     
170.         return false;
     
171.     }
     
172. 
     
173.     return result;
     
174. #else
     
175.     if (pthread_rwlock_unlock(&m_RWLock)!= 0)
     
176.     {
     
177.         throw TCException("TCRWLock::ReleaseWriteLock() exception!");
     
178.     }
     
179. 
     
180.     return true;
     
181. #endif
     
182. }

条件变量

     条件变量分为两部分: 条件和变量. 条件本身是由互斥量保护的. 线程在改变条件状态前先要锁住互斥量.

1. 初始化:

    条件变量采用的数据类型是pthread_cond_t, 在使用之前必须要进行初始化, 这包括两种方式:

静态: 可以把常量PTHREAD_COND_INITIALIZER给静态分配的条件变量.
动态: pthread_cond_init函数, 是释放动态条件变量的内存空间之前, 要用pthread_cond_destroy对其进行清理.
#include <pthread.h>

int pthread_cond_init(pthread_cond_t *restrict cond, pthread_condattr_t *restrict attr);
int pthread_cond_destroy(pthread_cond_t *cond);

成功则返回0, 出错则返回错误编号.
    当pthread_cond_init的attr参数为NULL时, 会创建一个默认属性的条件变量; 非默认情况以后讨论.

2. 等待条件:

#include <pthread.h>

int pthread_cond_wait(pthread_cond_t *restrict cond, pthread_mutex_t *restric mutex);
int pthread_cond_timedwait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex, const struct timespec *restrict timeout);

成功则返回0, 出错则返回错误编号.
    这两个函数分别是阻塞等待和超时等待.

    等待条件函数等待条件变为真, 传递给pthread_cond_wait的互斥量对条件进行保护, 调用者把锁住的互斥量传递给函数. 函数把调用线程放到等待条件的线程列表上, 然后对互斥量解锁, 这两个操作是原子的. 这样便关闭了条件检查和线程进入休眠状态等待条件改变这两个操作之间的时间通道, 这样线程就不会错过条件的任何变化.

    当pthread_cond_wait返回时, 互斥量再次被锁住.

3. 通知条件:

#include <pthread.h>

int pthread_cond_signal(pthread_cond_t *cond);
int pthread_cond_broadcast(pthread_cond_t *cond);

成功则返回0, 出错则返回错误编号.
    这两个函数用于通知线程条件已经满足. 调用这两个函数, 也称向线程或条件发送信号. 必须注意, 一定要在改变条件状态以后再给线程发送信号.

 

1. ///
   
2. /// @file Lock.h
   
3. /// @brief
   
4. /// @author guozhiming
   
5. /// @date 2007-04-11
   
6. ///
   
7. 
   
8. #ifndef __LOCK__
   
9. #define __LOCK__
   
10. #include "def.h"
    
11. 
    
12. /// @brief 锁的基本操作 1：读操作的时候读锁可以并发 2：写操作的时候，独占操作
    
13. class G_Lock
    
14. {
    
15.     public:
    
16.         
    
17.         /// @brief 构造函数初始化互斥锁, 条件变量
    
18.         G_Lock();
    
19. 
    
20.         /// @brief 析构函数释放互斥锁，和条件变量
    
21.         ~G_Lock();
    
22. 
    
23.         /// @brief 读锁 readCounter++, 锁住readCounter
    
24.         void rLock();
    
25. 
    
26.         /// @brief 解锁 readCounter--, 如果readCounter = 0, pthread_cond_signal通知
    
27.         void unrLock();
    
28. 
    
29.         /// @brief 写锁 如果readCounter不为0一直 pthread_cond_wait等待下去
    
30.         void wLock();
    
31. 
    
32.         /// @brief 解锁
    
33.         void unwLock();
    
34.     
    
35.     private:
    
36.         pthread_mutex_t r_Mutex; ///读锁 ，锁住readCounter
    
37. 
    
38.         pthread_mutex_t w_Mutex; ///锁住同步资源
    
39.         
    
40.         unsigned long readCounter; ///条件变量如果为0通知(pthread_cond_signal)
    
41. 
    
42.         pthread_cond_t condReadCounter;
    
43. };
    
44. 
    
45. 
    
46. #endif
47. 1. ///
       
    2. /// @file Lock.cpp
       
    3. /// @brief
       
    4. /// @author guozhiming
       
    5. /// @date 2007-04-11
       
    6. ///
       
    7. #include "Lock.h"
       
    8. 
       
    9. G_Lock::G_Lock()
       
    10. {
        
    11.     pthread_mutex_init(&r_Mutex, NULL);
        
    12.     pthread_mutex_init(&w_Mutex, NULL);
        
    13.     pthread_cond_init(&condReadCounter, NULL);
        
    14.     readCounter = 0;
        
    15. }
        
    16. 
        
    17. G_Lock::~G_Lock()
        
    18. {
        
    19.     pthread_mutex_destroy(&r_Mutex);
        
    20.     pthread_mutex_destroy(&w_Mutex);
        
    21.     pthread_cond_destroy(&condReadCounter);
        
    22. }
        
    23. 
        
    24. void G_Lock::rLock()
        
    25. {
        
    26.     pthread_mutex_lock(&w_Mutex);//防止于写操作冲突
        
    27.     pthread_mutex_lock(&r_Mutex);//防止readCounter 冲突
        
    28.     readCounter++;
        
    29.     pthread_mutex_unlock(&w_Mutex);///写解锁
        
    30.     pthread_mutex_unlock(&r_Mutex);///读解锁
        
    31. }
        
    32. 
        
    33. void G_Lock::unrLock()
        
    34. {
        
    35.     pthread_mutex_lock(&r_Mutex);///读加锁
        
    36.     readCounter--;
        
    37.     if(0== readCounter)
        
    38.     {
        
    39.         pthread_cond_signal(&condReadCounter);//如果readCounter为0, 表示已经没有读了，可以写
        
    40.     }
        
    41.     pthread_mutex_unlock(&r_Mutex);///读解锁
        
    42. }
        
    43. 
        
    44. void G_Lock::wLock()
        
    45. {
        
    46.     pthread_mutex_lock(&w_Mutex);///写加锁
        
    47.     pthread_mutex_lock(&r_Mutex);///读加锁
        
    48.     if(0== readCounter)///防止readCounter= 0而且没有调用过rLock()和unrLock()
        
    49.     {
        
    50.         pthread_mutex_unlock(&r_Mutex);///读解锁
        
    51.         return ;
        
    52.     }
        
    53.     pthread_cond_wait(&condReadCounter, &r_Mutex);//等待readCounter= 0 , 等待期间r_Mutex被解锁，有信号再加锁
        
    54.     pthread_mutex_unlock(&r_Mutex);///读解锁
        
    55. }
        
    56. 
        
    57. void G_Lock::unwLock()
        
    58. {
        
    59.     pthread_mutex_unlock(&w_Mutex);//写解锁
        
    60. }