徐培森的Blog Java 什么是死锁?如何避免死锁? 以及实现线程死锁才程序

什么是死锁?如何避免死锁? 以及实现线程死锁才程序

死锁是什么 所谓死锁:是指两个或两个以上的进程在执行过程中,因争夺资源而造成的一种互相等待的现象,若无外力作用…

死锁是什么

所谓死锁:是指两个或两个以上的进程在执行过程中,因争夺资源而造成的一种互相等待的现象,若无外力作用,它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁,这些永远在互相等待的进程称为死锁进程。由于资源占用是互斥的,当某个进程提出申请资源后,使得有关进程在无外力协助下,永远分配不到必需的资源而无法继续运行,这就产生了一种特殊现象死锁。

死锁的必要条件

虽然进程在运行过程中,可能发生死锁,但死锁的发生也必须具备一定的条件,死锁的发生必须具备以下四个必要条件

1)互斥条件:指进程对所分配到的资源进行排它性使用,即在一段时间内某资源只由一个进程占用。如果此时还有其它进程请求资源,则请求者只能等待,直至占有资源的进程用毕释放。

2)请求和保持条件:指进程已经保持至少一个资源,但又提出了新的资源请求,而该资源已被其它进程占有,此时请求进程阻塞,但又对自己已获得的其它资源保持不放。

3)不剥夺条件:指进程已获得的资源,在未使用完之前,不能被剥夺,只能在使用完时由自己释放。

4)环路等待条件:指在发生死锁时,必然存在一个进程——资源的环形链,即进程集合{P0P1P2···Pn}中的P0正在等待一个P1占用的资源;P1正在等待P2占用的资源,……Pn正在等待已被P0占用的资源。

在系统中已经出现死锁后,应该及时检测到死锁的发生,并采取适当的措施来解除死锁。目前处理死锁的方法可归结为以下四种:

预防死锁

  这是一种较简单和直观的事先预防的方法。方法是通过设置某些限制条件,去破坏产生死锁的四个必要条件中的一个或者几个,来预防发生死锁。预防死锁是一种较易实现的方法,已被广泛使用。但是由于所施加的限制条件往往太严格,可能会导致系统资源利用率和系统吞吐量降低。

 避免死锁

  该方法同样是属于事先预防的策略,但它并不须事先采取各种限制措施去破坏产生死锁的的四个必要条件,而是在资源的动态分配过程中,用某种方法去防止系统进入不安全状态,从而避免发生死锁。(安全状态、银行家算法)

检测死锁

  这种方法并不须事先采取任何限制性措施,也不必检查系统是否已经进入不安全区,此方法允许系统在运行过程中发生死锁。但可通过系统所设置的检测机构,及时地检测出死锁的发生,并精确地确定与死锁有关的进程和资源,然后采取适当措施,从系统中将已发生的死锁清除掉。(死锁定理化简资源分配图)

解除死锁

  这是与检测死锁相配套的一种措施。当检测到系统中已发生死锁时,须将进程从死锁状态中解脱出来。常用的实施方法是撤销或挂起一些进程,以便回收一些资源,再将这些资源分配给已处于阻塞状态的进程,使之转为就绪状态,以继续运行。死锁的检测和解除措施,有可能使系统获得较好的资源利用率和吞吐量,但在实现上难度也最大。(资源剥夺法,撤销进程法,进程回退法)

用两个线程请求被对方占用的资源,实现线程死锁

 

[java] view plain copy
  1. /** 

  2.  * 用两个线程请求被对方占用的资源,实现线程死锁 

  3.  */  

  4. public class DeadLockThread implements Runnable {  

  5.     private static final Object objectA = new Object();  

  6.     private static final Object objectB = new Object();  

  7.     private boolean flag;  

  8.   

  9.     @Override  

  10.     public void run() {  

  11.         String threadName = Thread.currentThread().getName();  

  12.         System.out.println("当前线程 为:"   

  13.         + threadName + "\tflag = " + flag);  

  14.         if (flag) {  

  15.             synchronized (objectA) {  

  16.                 try {  

  17.                     Thread.sleep(1000);  

  18.                 } catch (InterruptedException e) {  

  19.                     e.printStackTrace();  

  20.                 }  

  21.                 System.out.println(threadName   

  22.                         + "已进入同步代码块objectA,准备进入objectB");  

  23.                 synchronized (objectB) {  

  24.                     System.out.println(threadName   

  25.                             + "已经进入同步代码块objectB");  

  26.                 }  

  27.             }  

  28.   

  29.         } else {  

  30.             synchronized (objectB) {  

  31.                 try {  

  32.                     Thread.sleep(1000);  

  33.                 } catch (InterruptedException e) {  

  34.                     e.printStackTrace();  

  35.                 }  

  36.                 System.out.println(threadName   

  37.                         + "已进入同步代码块objectB,准备进入objectA");  

  38.                 synchronized (objectA) {  

  39.                     System.out.println(threadName   

  40.                             + "已经进入同步代码块objectA");  

  41.                 }  

  42.             }  

  43.         }  

  44.     }  

  45.   

  46.     public static void main(String[] args) {  

  47.         DeadLockThread deadlock1 = new DeadLockThread();  

  48.         DeadLockThread deadlock2 = new DeadLockThread();  

  49.         deadlock1.flag = true;  

  50.         deadlock2.flag = false;  

  51.         Thread thread1 = new Thread(deadlock1);  

  52.         Thread thread2 = new Thread(deadlock2);  

  53.         thread1.start();  

  54.         thread2.start();  

  55.   

  56.     }  

  57.   

  58. }  

[java] view plain copy
  1. 当前线程 为:Thread-0 flag = true  

  2. 当前线程 为:Thread-1 flag = false  

  3. Thread-1已进入同步代码块objectB,准备进入objectA  

  4. Thread-0已进入同步代码块objectA,准备进入objectB  

本文来自网络,不代表徐培森的Blog立场,转载请注明出处:https://blog.xupeisen.com/archives/111

作者: 培森

联系我们

联系我们

13262951234

在线咨询: QQ交谈

邮箱: admin@xupeisen.com

工作时间:周一至周五,9:00-17:30,节假日休息

关注微信
微信扫一扫关注我们

微信扫一扫关注我们

关注微博
返回顶部