多线程的那点儿事（之C++锁）

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

 

    编写程序不容易，编写多线程的程序更不容易。相信编写过多线程的程序都应该有这样的一个痛苦过程，什么样的情况呢？朋友们应该看一下代码就明白了，

[cpp] view plaincopyprint?

1. void data_process() 
2. { 
3.     EnterCriticalSection(); 
4.    
5.     if(/* error happens */) 
6.     { 
7.         LeaveCriticalSection(); 
8.         return; 
9.     } 
10.  
11.     if(/* other error happens */) 
12.     { 
13.         return; 
14.     } 
15.  
16.     LeaveCriticalSection(); 
17. } 

void data_process(){    EnterCriticalSection();      if(/* error happens */)    {        LeaveCriticalSection();        return;    }    if(/* other error happens */)    {        return;    }    LeaveCriticalSection();}

    上面的代码说明了一种情形。这种多线程的互斥情况在代码编写过程中是经常遇到的。所以，每次对共享数据进行操作时，都需要对数据进行EnterCriticalSection和LeaveCriticalSection的操作。但是，这中间也不是一帆风顺的。很有可能你会遇到各种各样的错误。那么，这时候你的程序就需要跳出去了。可能一开始遇到error的时候，你还记得需要退出临界区。但是，如果错误多了，你未必记得还有这个操作了。这一错就完了，别的线程就没有机会获取这个锁了。
    那么，有没有可能利用C++的特性，自动处理这种情况呢？还真有。我们看看下面这个代码，

[cpp] view plaincopyprint?

1. class CLock 
2. { 
3.     CRITICAL_SECTION& cs; 
4.  
5. public: 
6.     CLock(CRITICAL_SECTION& lock):cs(lock){ 
7.         EnterCriticalSection(&cs); 
8.     } 
9.  
10.     ~CLock() { 
11.         LeaveCriticalSection(&cs); 
12.     } 
13. } 
14.  
15. class Process 
16. { 
17.     CRITICAL_SECTION cs; 
18.     /* other data */ 
19.  
20. public: 
21.     Process(){ 
22.         InitializeCriticalSection(&cs); 
23.     } 
24.  
25.     ~Process() {DeleteCriticalSection(&cs);} 
26.  
27.     void data_process(){ 
28.         CLock lock(cs); 
29.  
30.         if(/* error happens */){ 
31.             return; 
32.         } 
33.  
34.         return; 
35.     } 
36. } 

class CLock{    CRITICAL_SECTION& cs;public:    CLock(CRITICAL_SECTION& lock):cs(lock){        EnterCriticalSection(&cs);    }    ~CLock() {        LeaveCriticalSection(&cs);    }}class Process{    CRITICAL_SECTION cs;    /* other data */public:    Process(){        InitializeCriticalSection(&cs);    }    ~Process() {DeleteCriticalSection(&cs);}    void data_process(){        CLock lock(cs);        if(/* error happens */){            return;        }        return;    }}

    C++的一个重要特点就是，不管函数什么时候退出，系统都会自动调用类的析构函数。在Process类的data_process函数中，，函数在开始就创建了一个CLock类。那么，在创建这个类的时候，其实就开始了临界区的pk。那么一旦进入到临界区当中，在error中能不能及时退出临界区呢？此时，c++析构函数的优势出现了。因为不管错误什么时候出现，在函数退出之前，系统都会帮我们善后。什么善后呢？就是系统会调用CLock的析构函数，也就是退出临界区。这样，我们的目的就达到了。
    其实，这就是一个c++的trick。