Java 程序死锁问题原理及解决方案

Java 程序死锁问题原理及解决方案内容简介 本文首先介绍了死锁发生的原因 并通过一个示例解释了死锁发生的前提情况 然后通过 JVM 的 jstack 工具演示了如何确定一个死锁的发生 最后对死锁的预防 恢复等方式进行了解释 参考文章链接 https www ibm com developerwor cn java j lo deadlock Java 语言通过

大家好,我是讯享网,很高兴认识大家。

内容简介 

本文首先介绍了死锁发生的原因,并通过一个示例解释了死锁发生的前提情况。然后通过 JVM 的 jstack 工具演示了如何确定一个死锁的发生。最后对死锁的预防、恢复等方式进行了解释。参考文章链接:https://www.ibm.com/developerworks/cn/java/j-lo-deadlock/

Java 语言通过 synchronized 关键字来保证原子性,这是因为每一个 Object 都有一个隐含的锁,这个也称作监视器对象。

在进入 synchronized 之前自动获取此内部锁,而一旦离开此方式,无论是完成或者中断都会自动释放锁。显然这是一个独占锁,每个锁请求之间是互斥的。相对于众多高级锁 (Lock/ReadWriteLock 等),synchronized 的代价都比后者要高。但是 synchronzied 的语法比较简单,而且也比较容易使用和理解。Lock 一旦调用了 lock() 方法获取到锁而未正确释放的话很有可能造成死锁,所以 Lock 的释放操作总是跟在 finally 代码块里面,这在代码结构上也是一次调整和冗余。Lock 的实现已经将硬件资源用到了极致,所以未来可优化的空间不大,除非硬件有了更高的性能,但是 synchronized 只是规范的一种实现,这在不同的平台不同的硬件还有很高的提升空间,未来 Java 锁上的优化也会主要在这上面。既然 synchronzied 都不可能避免死锁产生,那么死锁情况会是经常容易出现的错误,下面具体描述死锁发生的原因及解决方法。

死锁描述

死锁是操作系统层面的一个错误,是进程死锁的简称,最早在 1965 年由 Dijkstra 在研究银行家算法时提出的,它是计算机操作系统乃至整个并发程序设计领域最难处理的问题之一。

事实上,计算机世界有很多事情需要多线程方式去解决,因为这样才能最大程度上利用资源,才能体现出计算的高效。但是,实际上来说,计算机系统中有很多一次只能由一个进程使用的资源的情况,例如打印机,同时只能有一个进程控制它。在多通道程序设计环境中,若干进程往往要共享这类资源,而且一个进程所需要的资源还很有可能不止一个。因此,就会出现若干进程竞争有限资源,又推进顺序不当,从而构成无限期循环等待的局面。我们称这种状态为死锁。简单一点描述,死锁是指多个进程循环等待它方占有的资源而无限期地僵持下去的局面。很显然,如果没有外力的作用,那么死锁涉及到的各个进程都将永远处于封锁状态。

系统发生死锁现象不仅浪费大量的系统资源,甚至导致整个系统崩溃,带来灾难性后果。所以,对于死锁问题在理论上和技术上都必须予以高度重视。

银行家算法

一个银行家如何将一定数目的资金安全地借给若干个客户,使这些客户既能借到钱完成要干的事,同时银行家又能收回全部资金而不至于破产。银行家就像一个操作系统,客户就像运行的进程,银行家的资金就是系统的资源。

银行家算法需要确保以下四点:

  1. 当一个顾客对资金的最大需求量不超过银行家现有的资金时就可接纳该顾客;
  2. 顾客可以分期贷款, 但贷款的总数不能超过最大需求量;
  3. 当银行家现有的资金不能满足顾客尚需的贷款数额时,对顾客的贷款可推迟支付,但总能使顾客在有限的时间里得到贷款;
  4. 当顾客得到所需的全部资金后,一定能在有限的时间里归还所有的资金。

清单 1. 银行家算法实现

package com.zyt.banker; / * @author yitian.z 一共5个进程需要请求资源,有3类资源 */ public class BankDemo { // 每个进程所需要的最大资源数 public static int MAX[][] = { { 7, 5, 3 }, { 3, 2, 2 }, { 9, 0, 2 }, { 2, 2, 2 }, { 4, 3, 3 } }; // 系统拥有的初始资源数 public static int AVAILABLE[] = { 10, 5, 7 }; // 系统已给每个进程分配在资源数 public static int ALLOCATION[][] = { { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 } }; // 每个进程还需要的资源数 public static int NEED[][] = { { 7, 5, 3 }, { 3, 2, 2 }, { 9, 0, 2 }, { 2, 2, 2 }, { 4, 3, 3 } }; // 每次申请的资源数 public static int Request[] = { 0, 0, 0 }; // 进程数与资源数 public static int M = 5, N = 3; int FALSE = 0; int TRUE = 1; public void showdata() { System.out.println("系统可用资源数为:"); for (int i = 0; i < N; i++) { System.out.print("资源" + i + ":" + AVAILABLE[i] + ""); } System.out.println(); System.out.println("各进程还需要的资源数:"); for (int i = 0; i < M; i++) { System.out.print("进程" + i + ":"); for (int j = 0; j < N; j++) { System.out.print("资源" + j + ":" + NEED[i][j] + ""); } System.out.println(); } System.out.println(); System.out.println("各进程已经得到的资源量:"); for (int i = 0; i < M; i++) { System.out.print("进程"); System.out.println(i); for (int j = 0; j < N; j++) { System.out.print("资源" + j + ":" + ALLOCATION[i][j] + ""); } System.out.println(); } } // 分配资源,并重新更新各种状态 public void changdata(int k) { for (int i = 0; i < N; i++) { AVAILABLE[i] = AVAILABLE[i] - Request[i]; ALLOCATION[k][i] = ALLOCATION[k][i] + Request[i]; NEED[k][i] = NEED[k][i] - Request[i]; } } // 回收资源,并重新更新各种状态 public void rstordata(int k) { for (int i = 0; i < N; i++) { AVAILABLE[i] = AVAILABLE[i] + Request[i]; ALLOCATION[k][i] = ALLOCATION[k][i] - Request[i]; NEED[k][i] = NEED[k][i] + Request[i]; } } // 释放资源 public void free(int k) { for (int i = 0; i < N; i++) { AVAILABLE[i] = AVAILABLE[i] + ALLOCATION[k][i]; System.out.println("释放" + k + "号进程的" + i + "资源!"); } } public int check0(int k) { int n = 0; for (int i = 0; i < N; i++) { if (NEED[k][i] == 0) n++; } if (n == 3) return 1; else return 0; } // 检查安全性函数 // 所以银行家算法其核心是:保证银行家系统的资源数至少不小于一个 客户的所需要的资源数。在安全性检查函数chkerr()上由这个实现 // 这个循环来进行核心判断,从而完成银行家算法的安全性检查 public int chkerr(int s) { int WORK; int FINISH[] = new int[M], temp[] = new int[M];// 保存临时的安全进程序列 int i, k = 0; for (i = 0; i < M; i++) FINISH[i] = FALSE; for (int j = 0; j < N; j++) { WORK = AVAILABLE[j];// 第j个资源可用数 i = s; // 判断第i个进程是否满足条件 while (i < M) { if (FINISH[i] == FALSE && NEED[i][j] <= WORK) { WORK = WORK + ALLOCATION[i][j]; FINISH[i] = TRUE; temp[k] = i; k++; i = 0; } else { i++; } } for (i = 0; i < M; i++) { if (FINISH[i] == FALSE) { System.out.println("系统不安全!!!本次资源申请不成功!!!"); return 1; } } } System.out.println("经安全性检查,系统安全,本次分配成功。"); System.out.println("本次安全序列: "); for (i = 0; i < M - 1; i++) { System.out.print("进程" + temp[i] + "->"); } System.out.print("进程" + temp[M - 1]); System.out.println(); return 0; } }

讯享网

死锁示例

死锁问题是多线程特有的问题,它可以被认为是线程间切换消耗系统性能的一种极端情况。在死锁时,线程间相互等待资源,而又不释放自身的资源,导致无穷无尽的等待,其结果是系统任务永远无法执行完成。死锁问题是在多线程开发中应该坚决避免和杜绝的问题。

一般来说,要出现死锁问题需要满足以下条件:

1. 互斥条件:一个资源每次只能被一个线程使用。

2. 请求与保持条件:一个进程因请求资源而阻塞时,对已获得的资源保持不放。

3. 不剥夺条件:进程已获得的资源,在未使用完之前,不能强行剥夺。

4. 循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。

只要破坏死锁 4 个必要条件之一中的任何一个,死锁问题就能被解决。

我们先来看一个示例,前面说过,死锁是两个甚至多个线程被永久阻塞时的一种运行局面,这种局面的生成伴随着至少两个线程和两个或者多个资源。代码清单 2 所示的示例中,我们编写了一个简单的程序,它将会引起死锁发生,然后我们就会明白如何分析它。


讯享网

清单 2. 死锁示例

讯享网package com.zyt.banker; public class ThreadDeadlock { public static void main(String[] args) throws InterruptedException { Object obj1 = new Object(); Object obj2 = new Object(); Object obj3 = new Object(); Thread t1 = new Thread(new SyncThread(obj1, obj2), "t1"); Thread t2 = new Thread(new SyncThread(obj2, obj3), "t2"); Thread t3 = new Thread(new SyncThread(obj3, obj1), "t3"); t1.start(); Thread.sleep(5000); t2.start(); Thread.sleep(5000); t3.start(); } } class SyncThread implements Runnable { private Object obj1; private Object obj2; public SyncThread(Object obj1, Object obj2) { this.obj1 = obj1; this.obj2 = obj2; } @Override public void run() { String name = Thread.currentThread().getName(); System.out.println(name + " acquiring lock on " + obj1); synchronized (obj1) { System.out.println(name + " acquired lock on " + obj1); work(); System.out.println(name + " acquiring lock on " + obj2); synchronized (obj2) { System.out.println(name + " acquired lock on " + obj2); work(); } System.out.println(name + " released lock on " + obj2); } System.out.println(name + " released lock on " + obj1); System.out.println(name + " finished execution."); } private void work() { try { Thread.sleep(30000); } catch (InterruptedException e) { e.printStackTrace(); } } }

在上面的程序中同步线程正完成 Runnable 的接口,它工作的是两个对象,这两个对象向对方寻求死锁而且都在使用同步阻塞。在主函数中,我使用了三个为同步线程运行的线程,而且在其中每个线程中都有一个可共享的资源。这些线程以向第一个对象获取封锁这种方式运行。但是当它试着向第二个对象获取封锁时,它就会进入等待状态,因为它已经被另一个线程封锁住了。这样,在线程引起死锁的过程中,就形成了一个依赖于资源的循环。当我执行上面的程序时,就产生了输出,但是程序却因为死锁无法停止。输出如清单 3 所示。

清单 3. 清单 2 运行输出

t1 acquiring lock on java.lang.Object@3cf5b814 t1 acquired lock on java.lang.Object@3cf5b814 t2 acquiring lock on java.lang.Object@8523ca2 t2 acquired lock on java.lang.Object@8523ca2 t3 acquiring lock on java.lang.Object@6c89db9a t3 acquired lock on java.lang.Object@6c89db9a t1 acquiring lock on java.lang.Object@8523ca2 t2 acquiring lock on java.lang.Object@6c89db9a t3 acquiring lock on java.lang.Object@3cf5b814

在此我们可以清楚地在输出结果中辨认出死锁局面,但是在我们实际所用的应用中,发现死锁并将它排除是非常难的。

死锁情况诊断

JVM 提供了一些工具可以来帮助诊断死锁的发生,如下面程序清单 4 所示,我们实现了一个死锁,然后尝试通过 jstack 命令追踪、分析死锁发生。

清单 4. 死锁代码

讯享网package com.zyt.banker; import java.util.concurrent.locks.ReentrantLock; / * 下面演示一个简单的死锁,两个线程分别占用south和north锁,并同时请求对方占用的锁,导致死锁 * * @author yitian.z * */ public class DeadLock extends Thread { protected Object myDirect; static ReentrantLock south = new ReentrantLock(); static ReentrantLock north = new ReentrantLock(); public DeadLock(Object obj) { this.myDirect = obj; if (myDirect == south) { this.setName("south"); } else { this.setName("north"); } } @Override public void run() { if (myDirect == south) { try { north.lockInterruptibly();// 占用north Thread.sleep(500); south.lockInterruptibly(); System.out.println("car to south has passed"); } catch (InterruptedException e) { System.out.println("car to south is killed"); e.printStackTrace(); } finally { if (north.isHeldByCurrentThread()) { north.unlock(); } if (south.isHeldByCurrentThread()) { south.unlock(); } } } if (myDirect == north) { try { south.lockInterruptibly();// 占用south Thread.sleep(500); north.lockInterruptibly(); System.out.println("car to north has passed"); } catch (InterruptedException e) { System.out.println("car to north is killed"); e.printStackTrace(); } finally { if (north.isHeldByCurrentThread()) { north.unlock(); } if (south.isHeldByCurrentThread()) { south.unlock(); } } } } public static void main(String[] args) { DeadLock car2south = new DeadLock(south); DeadLock car2north = new DeadLock(north); car2south.start(); car2north.start(); } }

jstack 可用于导出 Java 应用程序的线程堆栈,-l 选项用于打印锁的附加信息。我们运行 jstack 命令,输出入清单 5 和 6 所示,其中清单 5 里面可以看到线程处于运行状态,代码中调用了拥有锁投票、定时锁等候和可中断锁等候等特性的 ReentrantLock 锁机制。清单 6 直接打印出出现死锁情况,报告 north 和 sourth 两个线程互相等待资源,出现了死锁。

清单5和6见:原文链接

死锁解决方案

死锁是由四个必要条件导致的,所以一般来说,只要破坏这四个必要条件中的一个条件,死锁情况就应该不会发生。

  1. 如果想要打破互斥条件,我们需要允许进程同时访问某些资源,这种方法受制于实际场景,不太容易实现条件;
  2. 打破不可抢占条件,这样需要允许进程强行从占有者那里夺取某些资源,或者简单一点理解,占有资源的进程不能再申请占有其他资源,必须释放手上的资源之后才能发起申请,这个其实也很难找到适用场景;
  3. 进程在运行前申请得到所有的资源,否则该进程不能进入准备执行状态。这个方法看似有点用处,但是它的缺点是可能导致资源利用率和进程并发性降低;
  4. 避免出现资源申请环路,即对资源事先分类编号,按号分配。这种方式可以有效提高资源的利用率和系统吞吐量,但是增加了系统开销,增大了进程对资源的占用时间。

如果我们在死锁检查时发现了死锁情况,那么就要努力消除死锁,使系统从死锁状态中恢复过来。消除死锁的几种方式:

1. 最简单、最常用的方法就是进行系统的重新启动,不过这种方法代价很大,它意味着在这之前所有的进程已经完成的计算工作都将付之东流,包括参与死锁的那些进程,以及未参与死锁的进程;

2. 撤消进程,剥夺资源。终止参与死锁的进程,收回它们占有的资源,从而解除死锁。这时又分两种情况:一次性撤消参与死锁的全部进程,剥夺全部资源;或者逐步撤消参与死锁的进程,逐步收回死锁进程占有的资源。一般来说,选择逐步撤消的进程时要按照一定的原则进行,目的是撤消那些代价最小的进程,比如按进程的优先级确定进程的代价;考虑进程运行时的代价和与此进程相关的外部作业的代价等因素;

3. 进程回退策略,即让参与死锁的进程回退到没有发生死锁前某一点处,并由此点处继续执行,以求再次执行时不再发生死锁。虽然这是个较理想的办法,但是操作起来系统开销极大,要有堆栈这样的机构记录进程的每一步变化,以便今后的回退,有时这是无法做到的。

其实即便是商业产品,依然会有很多死锁情况的发生,例如 MySQL 数据库,它也经常容易出现死锁案例。

避免死锁

  • 避免嵌套封锁:这是死锁的主要发生原因,如果你已经有一个资源就要避免封锁另一个资源。如果你运行时只有一个对象封锁,那是几乎不可能出现一个死锁局面的。例如,这里是另一个运行中没有嵌套封锁的run方法,而且程序运行没有死锁局面。run方法代码如下:
@Override public void run() { String name = Thread.currentThread().getName(); System.out.println(name + " acquiring lock on " + obj1); synchronized (obj1) { System.out.println(name + " acquired lock on " + obj1); } System.out.println(name + " released lock on " + obj1); System.out.println(name + " acquiring lock on " + obj2); synchronized (obj2) { System.out.println(name + " acquired lock on " + obj2); } System.out.println(name + " released lock on " + obj2); System.out.println(name + " finished execution"); }

运行代码如下:

讯享网t1 acquiring lock on java.lang.Object@30c028cc t1 acquired lock on java.lang.Object@30c028cc t1 released lock on java.lang.Object@30c028cc t1 acquiring lock on java.lang.Object@17b68215 t1 acquired lock on java.lang.Object@17b68215 t1 released lock on java.lang.Object@17b68215 t1 finished execution t2 acquiring lock on java.lang.Object@17b68215 t2 acquired lock on java.lang.Object@17b68215 t2 released lock on java.lang.Object@17b68215 t2 acquiring lock on java.lang.Object@ t2 acquired lock on java.lang.Object@ t2 released lock on java.lang.Object@ t2 finished execution t3 acquiring lock on java.lang.Object@ t3 acquired lock on java.lang.Object@ t3 released lock on java.lang.Object@ t3 acquiring lock on java.lang.Object@30c028cc t3 acquired lock on java.lang.Object@30c028cc t3 released lock on java.lang.Object@30c028cc t3 finished execution
  • 只对有请求的进行封锁:你应当只想在你要运行的资源获取封锁,比如在上述程序中,我在封锁完全的对象的资源。但是如果我们只对它所属领域中的一个感兴趣,那我们应当封锁住那个特殊的领域而并非完全的对象。
  • 避免无期限的等待:如果两个线程正在等待对象结束,无期限的使用线程,则最好为线程设置最长等待时间以避免死锁的发生。
小讯
上一篇 2025-01-18 16:21
下一篇 2025-01-17 18:32

相关推荐

版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容,请联系我们,一经查实,本站将立刻删除。
如需转载请保留出处:https://51itzy.com/kjqy/80119.html