CRITICAL_SECTION同步易出错的地方

众所周知通过CRITICAL_SECTION可以对多个线程同步，然而加锁和解锁的次数不匹配将导致死锁：

[cpp] view plaincopy

1. 1. 
      
2. class CLock
3. {
4. public:
5. CLock()
6. {
7. InitializeCriticalSection(&m_cs);
8. }
9. 
   
10. ~CLock()
11. {
12. DeleteCriticalSection(&m_cs);
13. }
14. 
    
15. void Lock()
16. {
17. EnterCriticalSection(&m_cs);
18. }
19. 
    
20. void Unlock()
21. {
22. LeaveCriticalSection(&m_cs);
23. }
24. private:
25. CRITICAL_SECTION m_cs;
26. };
    1. 
       

[cpp] view plaincopy

1. 1. 
      
2. int _tmain(int argc, _TCHAR* argv[])
3. {
4. unsigned ThreadId1, ThreadId2;
5. HANDLE hThread1, hThread2;
6. hThread1 = (HANDLE)_beginthreadex(0, 0, ThreadFun, NULL, 0, &ThreadId1);
7. Sleep(1000);
8. hThread2 = (HANDLE)_beginthreadex(0, 0, ThreadFun, NULL, 0, &ThreadId2);
9. 
   
10. getchar();
11. 
    
12. InterlockedCompareExchange(&gExit, 1, gExit);
13. WaitForSingleObject(hThread1, -1);
14. WaitForSingleObject(hThread2, -1);
15. 
    
16. return 0;
17. }
    1. 
       

1、线程A加锁两次、解锁一次，将导致线程B一直不能获得锁：

[cpp] view plaincopy

1. 1. 
      
2. long gExit = 0;
3. CLock gLock;
4. 
   
5. unsigned int _stdcall ThreadFun(void* argv)
6. {
7. while (true)
8. {
9. gLock.Lock();
10. gLock.Lock();
11. if (InterlockedCompareExchange(&gExit, gExit, 0))
12. {
13. return 0;
14. gLock.Unlock();
15. }
16. 
    
17. printf("Thread(%d) is Running\n", GetCurrentThreadId());
18. 
    
19. gLock.Unlock();
20. //gLock.Unlock();
21. 
    
22. Sleep(100);
23. }
24. }
    1. 
       

2、线程A加锁一次，解锁两次，当线程A下次再试图获得锁，将不能获取的到陷入死等，也将导致死锁，同理线程B。：

[cpp] view plaincopy

1. 1. 
      
2. unsigned int _stdcall ThreadFun(void* argv)
3. {
4. while (true)
5. {
6. // 加锁一次
7. gLock.Lock();
8. //gLock.Lock();
9. if (InterlockedCompareExchange(&gExit, gExit, 0))
10. {
11. return 0;
12. gLock.Unlock();
13. }
14. 
    
15. printf("Thread(%d) is Running\n", GetCurrentThreadId());
16. 
    
17. // 解锁两次，下次gLock.Lock()将陷入死等
18. gLock.Unlock();
19. gLock.Unlock();
20. 
    
21. Sleep(100);
22. }
23. }
    1. 
       

3、解决，可以定义一个自动获得锁，保证加锁和解锁完全匹配：

[cpp] view plaincopy

1. 1. 
      
2. class AutoLock
3. {
4. public:
5. AutoLock()
6. {
7. m_lock.Lock();
8. }
9. ~AutoLock()
10. {
11. m_lock.Unlock();
12. }
13. 
    
14. private:
15. CLock m_lock;
16. 
    
17. private:
18. AutoLock(const AutoLock& lock);
19. AutoLock& operator=(const AutoLock& lock);
20. };
    1. 
       

[cpp] view plaincopy

1. 1. 
      
2. unsigned int _stdcall ThreadFun(void* argv)
3. {
4. while (true)
5. {
6. AutoLock auto_lock;
7. if (InterlockedCompareExchange(&gExit, gExit, 0))
8. {
9. return 0;
10. }
11. 
    
12. printf("Thread(%d) is Running\n", GetCurrentThreadId());
13. 
    
14. Sleep(100);
15. }
16. }
    1. 
       

4、后记：以上是最简单的锁实现，加锁和解锁往往导致效率低下，以此改进，使用读写锁、闩锁等不同的加锁粒度来提升性能。