转载 多线程的那点儿事（之避免死锁）

Cand

预防死锁的注意事项：
（1）在编写多线程程序之前，首先编写正确的程序，然后再移植到多线程
（2）时刻检查自己写的程序有没有在跳出时忘记释放锁
（3）如果自己的模块可能重复使用一个锁，建议使用嵌套锁
（4）对于某些锁代码，不要临时重新编写，建议使用库里面的锁，或者自己曾经编写的锁
（5）如果某项业务需要获取多个锁，必须保证锁的按某种顺序获取，否则必定死锁
（6）编写简单的测试用例，验证有没有死锁
（7）编写验证死锁的程序，从源头避免死锁

    首先，定义基本的数据结构和宏，

1. typedef struct _LOCK_INFO   
   
2. {   
   
3.     char lockName[32];   
   
4.     HANDLE hLock;   
   
5. }LOCK_INFO:   
   
6.    
   
7. typedef struct _THREAD_LOCK   
   
8. {   
   
9.     int threadId;   
   
10.     LOCK_INFO* pLockInfo[32];   
    
11. }THREAD_LOCK;   
    
12.    
    
13. #define CRITICAL_SECTION_TYPE 1   
    
14. #define MUTEX_LOCK_TYPE       2   
    
15. #define SEMAPHORE_LOCK_TYPE   3   
    
16. #define NORMAL_LOCK_TYPE      4   
    
17.    
    
18. #define WaitForSingleObject(a, b) \   
    
19.         WaitForSingleObject_stub((void*)a, NORMAL_LOCK_TYPE)   
    
20.    
    
21. #define EnterCriticalSection(a) \   
    
22.         WaitForSingleObject_stub((void*)a, CRITICAL_SECTION_TYPE)   
    
23.    
    
24. #define ReleaseMutex(a) \   
    
25.         ReleaseLock_stub((void*)a, MUTEX_LOCK_TYPE))   
    
26.    
    
27. #define ReleaseSemaphore(a, b, c) \   
    
28.         ReleaseLock_stub((void*)a, SEMAPHORE_LOCK_TYPE))   
    
29.    
    
30. #define LeaveCriticalSection(a) \   
    
31.         ReleaseLock_stub((void*)a, CRITICAL_SECTION_TYPE))  

复制代码

然后，改写锁的申请函数，

1. void WaitForSingleObject_stub(void* hLock, int type)   
   
2. {   
   
3.     /* step 1 */   
   
4.     WaitForSingleObject(hDbgLock);   
   
5.     /* check if lock loops arounds threads */   
   
6.     ReleaseMutex(hDbgLock);   
   
7.    
   
8.     /* step 2 */   
   
9.     if(NORMAL_LOCK_TYPE == type)   
   
10.         WaitForSingleObject((HANDLE)hLock, INFINITE);   
    
11.     else if(CRITICAL_SECTION_TYPE == type)   
    
12.         EnterCriticalSection((LPCRITICAL_SECTION)hLock);   
    
13.     else   
    
14.         assert(0);   
    
15.    
    
16.     /* step 3 */   
    
17.     WaitForSingleObject(hDbgLock);   
    
18.     /* add lock to specified threadid list */   
    
19.     ReleaseMutex(hDbgLock);   
    
20. }  
    
21. void WaitForSingleObject_stub(void* hLock, int type)
    
22. {
    
23.     /* step 1 */
    
24.     WaitForSingleObject(hDbgLock);
    
25.     /* check if lock loops arounds threads */
    
26.     ReleaseMutex(hDbgLock);
    
27. 
    
28.     /* step 2 */
    
29.     if(NORMAL_LOCK_TYPE == type)
    
30.         WaitForSingleObject((HANDLE)hLock, INFINITE);
    
31.     else if(CRITICAL_SECTION_TYPE == type)
    
32.         EnterCriticalSection((LPCRITICAL_SECTION)hLock);
    
33.     else
    
34.         assert(0);
    
35. 
    
36.     /* step 3 */
    
37.     WaitForSingleObject(hDbgLock);
    
38.     /* add lock to specified threadid list */
    
39.     ReleaseMutex(hDbgLock);
    
40. }

复制代码

最后，需要改写锁的释放函数。

1. void ReleaseLock_stub(void* hLock, int type)   
   
2. {   
   
3.     /* step 1 */   
   
4.     WaitForSingleObject(hDbgLock);   
   
5.     /* remove lock from specified threadid list */   
   
6.     ReleaseMutex(hDbgLock);   
   
7.    
   
8.     /* step 2 */   
   
9.     if(MUTEX_LOCK_TYPE))== type)   
   
10.         ReleaseMutex(HANDLE)hLock);   
    
11.     else if(SEMAPHORE_LOCK_TYPE == type)   
    
12.         ReleaseSemaphore((HANDLE)hLock, 1, NULL);   
    
13.     else if(CRITICAL_SECTION_TYPE == type)   
    
14.         LeaveCriticalSection((LPCRITICAL_SECTION)hLock);   
    
15.     assert(0);   
    
16. }  
    
17. void ReleaseLock_stub(void* hLock, int type)
    
18. {
    
19.     /* step 1 */
    
20.     WaitForSingleObject(hDbgLock);
    
21.     /* remove lock from specified threadid list */
    
22.     ReleaseMutex(hDbgLock);
    
23. 
    
24.     /* step 2 */
    
25.     if(MUTEX_LOCK_TYPE))== type)
    
26.         ReleaseMutex(HANDLE)hLock);
    
27.     else if(SEMAPHORE_LOCK_TYPE == type)
    
28.         ReleaseSemaphore((HANDLE)hLock, 1, NULL);
    
29.     else if(CRITICAL_SECTION_TYPE == type)
    
30.         LeaveCriticalSection((LPCRITICAL_SECTION)hLock);
    
31.     assert(0);
    
32. }

复制代码

ㄣ负二代

一定要顶！！！！！！！！！！！！！！！