线程死锁问题

来源:互联网 发布:阿里云到底是什么 编辑:程序博客网 时间:2024/05/16 07:06
  1. using System;  
  2. using System.Threading;  
  3. using System.Diagnostics;  
  4.   
  5. namespace ConsoleApplication1  
  6. {  
  7.     class StateObject  
  8.     {  
  9.         private int state = 5;  
  10.   
  11.         public void ChangeState(int loop)  
  12.         {  
  13.             if (state == 5)  
  14.             {  
  15.                 state++;  
  16.                 Trace.Assert(state == 6, "Race condition occurred after" + loop + " loops");  
  17.             }  
  18.   
  19.             state = 5;  
  20.         }  
  21.     }  
  22.   
  23.     class SampleThread  
  24.     {  
  25.         private StateObject s1;  
  26.         private StateObject s2;  
  27.   
  28.         public SampleThread(StateObject s1, StateObject s2)  
  29.         {  
  30.             this.s1 = s1;  
  31.             this.s2 = s2;  
  32.         }  
  33.   
  34.         /* 由于Deadlock1(),Deadlock2()中方法定义的锁定对象的顺序不同最终导致了死锁 */  
  35.         public void Deadlock1()  
  36.         {  
  37.             int i = 0;  
  38.   
  39.             while (true)  
  40.             {  
  41.                 lock (s1)  
  42.                 {  
  43.                     lock (s2)  
  44.                     {  
  45.                         s1.ChangeState(i);  
  46.                         s2.ChangeState(i++);  
  47.   
  48.                         Console.WriteLine("运行," + i);  
  49.                     }  
  50.                 }  
  51.             }  
  52.         }  
  53.   
  54.         public void Deadlock2()  
  55.         {  
  56.             int i = 0;  
  57.   
  58.             while (true)  
  59.             {  
  60.                 lock (s2)  
  61.                 {  
  62.                     lock (s1)  
  63.                     {  
  64.                         s1.ChangeState(i);  
  65.                         s2.ChangeState(i++);  
  66.   
  67.                         Console.WriteLine("运行," + i);  
  68.                     }  
  69.                 }  
  70.             }  
  71.         }  
  72.     }  
  73.   
  74.     class Program  
  75.     {  
  76.         static void Main(string[] args)  
  77.         {  
  78.             /* 死锁 
  79.              * 至少有两个线程被挂起,等待对方解除锁定 
  80.              * 线程将无限等待下去 
  81.              */  
  82.             StateObject state1 = new StateObject();  
  83.             StateObject state2 = new StateObject();  
  84.   
  85.             //此程序中第一个线程如果先锁定s1,同时第二个线程先锁定s2  
  86.             //然后第一个线程在企图锁定s2时,发现s2已被锁定,于是开始等待s2解锁  
  87.             //同时第二个线程企图锁定s1时,发现s1已被锁定,于是开始等待s1解锁  
  88.             //但对于线程一来说如果s2不解锁,其也无法完成程序,对于线程二也是如此  
  89.             //于是无穷的互相等待解锁开始了,死锁开始啦!  
  90.   
  91.             //避免死锁,可以从一开始定义好锁定的顺序,也可以为锁定定义超时时间^-^  
  92.             new Thread(new SampleThread(state1, state2).Deadlock1).Start();  
  93.             new Thread(new SampleThread(state1, state2).Deadlock2).Start();  
  94.         }  
  95.   
  96.   
  97.     }  

0 0