精易论坛

标题: 转载 多线程的那点儿事（之避免死锁） [打印本页]
作者: Cand    时间: 2012-6-27 11:15
标题: 转载 多线程的那点儿事（之避免死锁）
预防死锁的注意事项：
（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);

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

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

  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. }
复制代码
作者: ㄣ负二代    时间: 2012-7-11 06:13
一定要顶！！！！！！！！！！！！！！！



欢迎光临 精易论坛 (https://125.confly.eu.org/) Powered by Discuz! X3.4