多线程的异步性,访问资源的时候可能会出现互相竞争一个资源的情况,如果多个资源各自占有资源,并且不释放系统就会处于死锁状态

  1. #region 死锁  
  2.        private void btnDeadLock_Click(object sender, EventArgs e)  
  3.        {  
  4.            deathLock1 = new DeathLock();  
  5.            deathLock2 = new DeathLock();  
  6.            Thread thread1 = new Thread(deathLock1.DeathLockProA);  
  7.            Thread thread2 = new Thread(deathLock2.DeathLockProB);  
  8.            thread1.Start();  
  9.            thread2.Start();  
  10.        }  
  11.        #endregion 
  1. class DeathLock  
  2.     {  
  3.         #region 变量  
  4.         /// <summary>  
  5.         ///  
  6.         /// </summary>  
  7.           object objOne = new object();  
  8.           object objTwo = new object();  
  9.          
  10.         #endregion  
  11.  
  12.         #region 死锁的处理  
  13.         /// <summary>  
  14.         /// 死锁的处理  
  15.         /// </summary>  
  16.         public void DeathLockProA()  
  17.         {  
  18.             lock (objOne)  
  19.             {  
  20.                 Console.WriteLine("第一个进程锁定1,等待资源2");  
  21.                 Thread.Sleep(2000);  
  22.  
  23.                 lock (objTwo)  
  24.                 {  
  25.                     Console.WriteLine("第一个进程锁定2");  
  26.                 }  
  27.             }  
  28.         }  
  29.  
  30.         public void DeathLockProB()  
  31.         {  
  32.             lock (objTwo)  
  33.             {  
  34.                 Console.WriteLine("第二个进程锁定2,等待资源1");  
  35.                 Thread.Sleep(2000);  
  36.  
  37.                 lock (objOne)  
  38.                 {  
  39.                     Console.WriteLine("第二个进程锁定1");  
  40.                 }  
  41.             }  
  42.         }  
  43.         #endregion  
  44.     } 

输出结果:

输出结果