转载 多线程的那点儿事（之死锁）

Cand

   相信有过多线程编程经验的朋友，都吃过死锁的苦。除非你不使用多线程，否则死锁的可能性会一直存在。为什么会出现死锁呢？我想原因主要有下面几个方面：
    （1）个人使用锁的经验差异
    （2）模块使用锁的差异
    （3）版本之间的差异
    （4）分支之间的差异
    （5）修改代码和重构代码带来的差异

    不管什么原因，死锁的危机都是存在的。那么，通常出现的死锁都有哪些呢？我们可以一个一个看过来，
    （1）忘记释放锁

1. void data_process()   
   
2. {   
   
3.     EnterCriticalSection();   
   
4.    
   
5.     if(/* error happens */)   
   
6.         return;   
   
7.    
   
8.     LeaveCriticalSection();   
   
9. }  
   

复制代码

（2）单线程重复申请锁

1. void sub_func()   
   
2. {   
   
3.     EnterCriticalSection();   
   
4.     do_something();   
   
5.     LeaveCriticalSection();   
   
6. }   
   
7.    
   
8. void data_process()   
   
9. {   
   
10.     EnterCriticalSection();   
    
11.     sub_func();   
    
12.     LeaveCriticalSection();   
    
13. }  
    

复制代码

（3）双线程多锁申请

1. void data_process1()   
   
2. {   
   
3.     EnterCriticalSection(&cs1);   
   
4.     EnterCriticalSection(&cs2);   
   
5.     do_something1();   
   
6.     LeaveCriticalSection(&cs2);   
   
7.     LeaveCriticalSection(&cs1);   
   
8. }   
   
9.    
   
10. void data_process2()   
    
11. {   
    
12.     EnterCriticalSection(&cs2);   
    
13.     EnterCriticalSection(&cs1);   
    
14.     do_something2();   
    
15.     LeaveCriticalSection(&cs1);   
    
16.     LeaveCriticalSection

复制代码

（4）环形锁申请

1. /*  
   
2. *             A   -  B  
   
3. *             |      |  
   
4. *             C   -  D  
   
5. */  

复制代码

假设有A、B、C、D四个人在一起吃饭，每个人左右各有一只筷子。所以，这其中要是有一个人想吃饭，他必须首先拿起左边的筷子，再拿起右边的筷子。现在，我们让所有的人同时开始吃饭。那么就很有可能出现这种情况。每个人都拿起了左边的筷子，或者每个人都拿起了右边的筷子，为了吃饭，他们现在都在等另外一只筷子。此时每个人都想吃饭，同时每个人都不想放弃自己已经得到的一那只筷子。所以，事实上大家都吃不了饭。

总结：
    （1）死锁的危险始终存在，但是我们应该尽量减少这种危害存在的范围
    （2）解决死锁花费的代价是异常高昂的
    （3）最好的死锁处理方法就是在编写程序的时候尽可能检测到死锁
    （4）多线程是一把双刃剑，有了效率的提高当然就有死锁的危险
    （5）某些程序的死锁是可以容忍的，大不了重启机器，但是有些程序不行

大头佛

支持支持！好精彩好形象的解说！

为幸福而战°

{:3_244:}，支持楼主转载的精彩解说啊。

该死╳滴命

往往往往往往往往往往往往往往往往我顶顶顶顶顶顶顶顶顶