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

【 声明：版权所有，欢迎转载，请勿用于商业用途。  联系信箱：feixiaoxing @163.com】

预防死锁的注意事项：

（1）在编写多线程程序之前，首先编写正确的程序，然后再移植到多线程

（2）时刻检查自己写的程序有没有在跳出时忘记释放锁

（3）如果自己的模块可能重复使用一个锁，建议使用嵌套锁

（4）对于某些锁代码，不要临时重新编写，建议使用库里面的锁，或者自己曾经编写的锁

（5）如果某项业务需要获取多个锁，必须保证锁的按某种顺序获取，否则必定死锁

（6）编写简单的测试用例，验证有没有死锁

（7）编写验证死锁的程序，从源头避免死锁

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

[cpp] view plain copy print ?

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)) 

typedef struct _LOCK_INFO
{
    char lockName[32];
    HANDLE hLock;
}LOCK_INFO:

typedef struct _THREAD_LOCK
{
    int threadId;
    LOCK_INFO* pLockInfo[32];
}THREAD_LOCK;

#define CRITICAL_SECTION_TYPE 1
#define MUTEX_LOCK_TYPE       2
#define SEMAPHORE_LOCK_TYPE   3
#define NORMAL_LOCK_TYPE      4

#define WaitForSingleObject(a, b) \
        WaitForSingleObject_stub((void*)a, NORMAL_LOCK_TYPE)

#define EnterCriticalSection(a) \
        WaitForSingleObject_stub((void*)a, CRITICAL_SECTION_TYPE)

#define ReleaseMutex(a) \
        ReleaseLock_stub((void*)a, MUTEX_LOCK_TYPE))

#define ReleaseSemaphore(a, b, c) \
        ReleaseLock_stub((void*)a, SEMAPHORE_LOCK_TYPE))

#define LeaveCriticalSection(a) \
        ReleaseLock_stub((void*)a, CRITICAL_SECTION_TYPE))

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

[cpp] view plain copy print ?

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. } 

void WaitForSingleObject_stub(void* hLock, int type)
{
    /* step 1 */
    WaitForSingleObject(hDbgLock);
    /* check if lock loops arounds threads */
    ReleaseMutex(hDbgLock);

    /* step 2 */
    if(NORMAL_LOCK_TYPE == type)
        WaitForSingleObject((HANDLE)hLock, INFINITE);
    else if(CRITICAL_SECTION_TYPE == type)
        EnterCriticalSection((LPCRITICAL_SECTION)hLock);
    else
        assert(0);

    /* step 3 */
    WaitForSingleObject(hDbgLock);
    /* add lock to specified threadid list */
    ReleaseMutex(hDbgLock);
}

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

[cpp] view plain copy print ?

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. }