精易论坛

标题: 转载 多线程的那点儿事（之C++锁） [打印本页]
作者: Cand    时间: 2012-6-27 10:59
标题: 转载 多线程的那点儿事（之C++锁）
     编写程序不容易，编写多线程的程序更不容易。相信编写过多线程的程序都应该有这样的一个痛苦过程，什么样的情况呢？朋友们应该看一下代码就明白了，
  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. }  
复制代码
上面的代码说明了一种情形。这种多线程的互斥情况在代码编写过程中是经常遇到的。所以，每次对共享数据进行操作时，都需要对数据进行EnterCriticalSection和LeaveCriticalSection的操作。但是，这中间也不是一帆风顺的。很有可能你会遇到各种各样的错误。那么，这时候你的程序就需要跳出去了。可能一开始遇到error的时候，你还记得需要退出临界区。但是，如果错误多了，你未必记得还有这个操作了。这一错就完了，别的线程就没有机会获取这个锁了。
    那么，有没有可能利用C++的特性，自动处理这种情况呢？还真有。我们看看下面这个代码，
  1. print?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. }  
  37. class CLock
  38. {
  39.     CRITICAL_SECTION& cs;

  41. public:
  42.     CLock(CRITICAL_SECTION& lock):cs(lock){
  43.         EnterCriticalSection(&cs);
  44.     }

  46.     ~CLock() {
  47.         LeaveCriticalSection(&cs);
  48.     }
  49. }

  51. class Process
  52. {
  53.     CRITICAL_SECTION cs;
  54.     /* other data */

  56. public:
  57.     Process(){
  58.         InitializeCriticalSection(&cs);
  59.     }

  61.     ~Process() {DeleteCriticalSection(&cs);}

  63.     void data_process(){
  64.         CLock lock(cs);

  66.         if(/* error happens */){
  67.             return;
  68.         }

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

作者: ㄣ负二代    时间: 2012-7-11 06:16
哇哇。。。必须支持你。。。。。。



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