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

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

预防死锁的注意事项：

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

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

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

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

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

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

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

 

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

[cpp] view plaincopy
  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))  

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

[cpp] view plaincopy
  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. }  

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

[cpp] view plaincopy
  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. } 
posted @ 2012-01-17 09:41  董雨  阅读(237)  评论(0)  编辑  收藏  举报