一篇带给你多线程死锁详解

一、什么是死锁

当两个或两个以上的线程在执行过程中，因为争夺资源而造成的一种相互等待的状态，由于存在一种环路的锁依赖关系而永远地等待下去，如果没有外部干涉，他们将永远等待下去，此时的这个状态称之为死锁。

在黑龙江等地区，都构建了全面的区域性战略布局，加强发展的系统性、市场前瞻性、产品创新能力，以专注、极致的服务理念，为客户提供网站设计、做网站 网站设计制作按需搭建网站,公司网站建设,企业网站建设,成都品牌网站建设,成都全网营销推广,成都外贸网站建设公司,黑龙江网站建设费用合理。

经典的 "哲学家进餐" 问题很好地描述了死锁状况：

  • 5个哲学家去吃中餐，坐在一张圆桌旁，他们有5根筷子(而不是5双)，并且每两个人中间放一根筷子，哲学家们要么在思考，要么在进餐，每个人都需要一双筷子才能吃到东西，并在吃完后将筷子放回原处继续思考，有些筷子管理算法(1)能够使每个人都能相对及时的吃到东西，但有些算法却可能导致一些或者所有哲学家都"饿死"，后一种情况将产生死锁：每个人都拥有其他人需要的资源，同时有等待其他人已经拥有的资源，并且每个人在获取所有需要的资源之前都不会放弃已经拥有的资源。筷子管理算法(1)：一个饥饿的科学家会尝试获得两根临近的筷子，但如果其中一根正在被另一个科学家使用，那么他将放弃已经得到的那根筷子，并在等待几分钟之后尝试

死锁：每个人都立即抓住自己左边的筷子，然后等待自己右边的筷子空出来，但同时又不放下已经拿到的筷子，形成一种相互等待的状态。饥饿：哲学家们都同时想吃饭，同时拿起左手边筷子，但是发现右边没有筷子，于是哲学家又同时放下左手边筷子，然后大家发现又有筷子了，又同时开始拿起左手边筷子，又同时放下，然后反复进行。

在线程A持有锁L并想获得锁M的同时，线程B持有锁M并尝试获得锁L，那么这两个线程将永远地等待下去，这种情况就是死锁形式(或者称为"抱死")

二、死锁的四个必要条件

  • 互斥条件：指进程对所分配到的资源进行排它性使用，即在一段时间内某资源只由一个进程占用。如果此时还有其它进程请求资源，则请求者只能等待，直至占有资源的进程用完释放。
  • 请求和保持条件：指进程已经保持至少一个资源，但又提出了新的资源请求，而该资源已被其它进程占有，此时请求进程阻塞，但又对自己已获得的其它资源保持不放。
  • 不剥夺条件：指进程已获得的资源，在未使用完之前，不能被剥夺，只能在使用完时由自己释放。
  • 环路等待条件：指在发生死锁时，必然存在一个进程——资源的环形链，即进程集合{A，B，C，···，Z} 中的A正在等待一个B占用的资源;B正在等待C占用的资源，……，Z正在等待已被A占用的资源。

三、死锁实例

 
 
 
 
      
  
  
  
  1. /** 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3. * 死锁类示例 
    4.   
  
  
  
  4.  
    5.   
  
  
  
  5. */ 
    6.   
  
  
  
  6.  
    7.   
  
  
  
  7. public class DeadLock implements Runnable { 
    8.   
  
  
  
  8.  
    9.   
  
  
  
  9. public int flag = 1; 
    10.   
  
  
  
  10.  
    11.   
  
  
  
  11. //静态对象是类的所有对象共享的 
    12.   
  
  
  
  12.  
    13.   
  
  
  
  13. private static Object o1 = new Object(), o2 = new Object(); 
    14.   
  
  
  
  14.  
    15.   
  
  
  
  15. @Override 
    16.   
  
  
  
  16.  
    17.   
  
  
  
  17. public void run() { 
    18.   
  
  
  
  18.  
    19.   
  
  
  
  19. System.out.println("flag:{}"+flag); 
    20.   
  
  
  
  20.  
    21.   
  
  
  
  21. if (flag == 1) { //先锁o1，再对o2加锁，环路等待条件 
    22.   
  
  
  
  22.  
    23.   
  
  
  
  23. synchronized (o1) { 
    24.   
  
  
  
  24.  
    25.   
  
  
  
  25. try { 
    26.   
  
  
  
  26.  
    27.   
  
  
  
  27. Thread.sleep(500); 
    28.   
  
  
  
  28.  
    29.   
  
  
  
  29. } catch (Exception e) { 
    30.   
  
  
  
  30.  
    31.   
  
  
  
  31. e.printStackTrace(); 
    32.   
  
  
  
  32.  
    33.   
  
  
  
  33. } 
    34.   
  
  
  
  34.  
    35.   
  
  
  
  35. synchronized (o2) { 
    36.   
  
  
  
  36.  
    37.   
  
  
  
  37. System.out.println("1"); 
    38.   
  
  
  
  38.  
    39.   
  
  
  
  39. } 
    40.   
  
  
  
  40.  
    41.   
  
  
  
  41. } 
    42.   
  
  
  
  42.  
    43.   
  
  
  
  43. } 
    44.   
  
  
  
  44.  
    45.   
  
  
  
  45. if (flag == 0) {//先锁o2，在锁01 
    46.   
  
  
  
  46.  
    47.   
  
  
  
  47. synchronized (o2) { 
    48.   
  
  
  
  48.  
    49.   
  
  
  
  49. try { 
    50.   
  
  
  
  50.  
    51.   
  
  
  
  51. Thread.sleep(500); 
    52.   
  
  
  
  52.  
    53.   
  
  
  
  53. } catch (Exception e) { 
    54.   
  
  
  
  54.  
    55.   
  
  
  
  55. e.printStackTrace(); 
    56.   
  
  
  
  56.  
    57.   
  
  
  
  57. } 
    58.   
  
  
  
  58.  
    59.   
  
  
  
  59. synchronized (o1) { 
    60.   
  
  
  
  60.  
    61.   
  
  
  
  61. System.out.println("0"); 
    62.   
  
  
  
  62.  
    63.   
  
  
  
  63. } 
    64.   
  
  
  
  64.  
    65.   
  
  
  
  65. } 
    66.   
  
  
  
  66.  
    67.   
  
  
  
  67. } 
    68.   
  
  
  
  68.  
    69.   
  
  
  
  69. } 
    70.   
  
  
  
  70.  
    71.   
  
  
  
  71. public static void main(String[] args) { 
    72.   
  
  
  
  72.  
    73.   
  
  
  
  73. DeadLock td1 = new DeadLock(); 
    74.   
  
  
  
  74.  
    75.   
  
  
  
  75. DeadLock td2 = new DeadLock(); 
    76.   
  
  
  
  76.  
    77.   
  
  
  
  77. td1.flag = 1; 
    78.   
  
  
  
  78.  
    79.   
  
  
  
  79. td2.flag = 0; 
    80.   
  
  
  
  80.  
    81.   
  
  
  
  81. //td1,td2都处于可执行状态，但JVM线程调度先执行哪个线程是不确定的。 
    82.   
  
  
  
  82.  
    83.   
  
  
  
  83. //td2的run()可能在td1的run()之前运行 
    84.   
  
  
  
  84.  
    85.   
  
  
  
  85. new Thread(td1).start(); 
    86.   
  
  
  
  86.  
    87.   
  
  
  
  87. new Thread(td2).start(); 
    88.   
  
  
  
  88.  
    89.   
  
  
  
  89. } 
    90.   
  
  
  
  90.  
    91.   
  
  
  
  91. } 
    92.

1、当DeadLock 类的对象flag=1时(td1)，先锁定o1,睡眠500毫秒2、而td1在睡眠的时候另一个flag==0的对象(td2)线程启动，先锁定o2,睡眠500毫秒3、td1睡眠结束后需要锁定o2才能继续执行，而此时o2已被td2锁定;4、td2睡眠结束后需要锁定o1才能继续执行，而此时o1已被td1锁定;5、td1、td2相互等待，都需要得到对方锁定的资源才能继续执行，从而死锁。

动态锁顺序死锁：

 
 
 
 
      
  
  
  
  1. // 资金转账到账号 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3. public static void transferMoney(Account fromAccount, 
    4.   
  
  
  
  4.  
    5.   
  
  
  
  5. Account toAccount, 
    6.   
  
  
  
  6.  
    7.   
  
  
  
  7. DollarAmount amount) 
    8.   
  
  
  
  8.  
    9.   
  
  
  
  9. throws InsufficientFundsException { 
    10.   
  
  
  
  10.  
    11.   
  
  
  
  11. // 锁定汇款者的账户 
    12.   
  
  
  
  12.  
    13.   
  
  
  
  13. synchronized (fromAccount) { 
    14.   
  
  
  
  14.  
    15.   
  
  
  
  15. // 锁定到账者的账户 
    16.   
  
  
  
  16.  
    17.   
  
  
  
  17. synchronized (toAccount) { 
    18.   
  
  
  
  18.  
    19.   
  
  
  
  19. // 判断账户的余额不能为负数 
    20.   
  
  
  
  20.  
    21.   
  
  
  
  21. if (fromAccount.getBalance().compareTo(amount) < 0) { 
    22.   
  
  
  
  22.  
    23.   
  
  
  
  23. throw new InsufficientFundsException(); 
    24.   
  
  
  
  24.  
    25.   
  
  
  
  25. } else { 
    26.   
  
  
  
  26.  
    27.   
  
  
  
  27. // 汇款者的账户减钱 
    28.   
  
  
  
  28.  
    29.   
  
  
  
  29. fromAccount.debit(amount); 
    30.   
  
  
  
  30.  
    31.   
  
  
  
  31. // 到账者的账户增钱 
    32.   
  
  
  
  32.  
    33.   
  
  
  
  33. toAccount.credit(amount); 
    34.   
  
  
  
  34.  
    35.   
  
  
  
  35. } 
    36.   
  
  
  
  36.  
    37.   
  
  
  
  37. } 
    38.   
  
  
  
  38.  
    39.   
  
  
  
  39. } 
    40.   
  
  
  
  40.  
    41.   
  
  
  
  41. } 
    42.

上面的代码看起来都是按照相同的顺序来获得锁的，按道理来说是没有问题，但是上述代码中上锁的顺序取决于传递给 transferMoney()的参数顺序，而这些参数顺序又取决于外部的输入

  • 如果两个线程(A和B)同时调用 transferMoney()
  • 其中一个线程(A)，从X向Y转账： transferMoney(myAccount,yourAccount,10);
  • 另一个线程(B)，从Y向X转账 ： transferMoney(yourAccount,myAccount,20);
  • 此时 A线程 可能获得 myAccount 的锁并等待 yourAccount的锁，然而 B线程 此时已经持有 yourAccount 的锁，并且正在等待 myAccount 的锁，这种情况下就会发生死锁。

当一组java线程发生死锁的时候，那么这些线程永远不能再使用了，根据线程完成工作的不同，可能会造成应用程序的完全停止，或者某个特定的子系统不能再使用了，或者是性能降低，这个时候恢复应用程序的唯一方式就是中止并重启它，死锁造成的影响很少会立即显现出来，如果一个类发生死锁，并不意味着每次都会发生死锁，而只是表示有可能，当死锁出现的时候，往往是在最糟糕的时候——在高负载的情况下。

四、死锁的避免与检测

4.1 预防死锁

  • 破坏互斥条件：使资源同时访问而非互斥使用，就没有进程会阻塞在资源上，从而不发生死锁
  • 破坏请求和保持条件：采用静态分配的方式，静态分配的方式是指进程必须在执行之前就申请需要的全部资源，且直至所要的资源全部得到满足后才开始执行，只要有一个资源得不到分配，也不给这个进程分配其他的资源。
  • 破坏不剥夺条件：即当某进程获得了部分资源，但得不到其它资源，则释放已占有的资源，但是只适用于内存和处理器资源。
  • 破坏循环等待条件：给系统的所有资源编号，规定进程请求所需资源的顺序必须按照资源的编号依次进行。

4.2 设置加锁顺序

如果两个线程(A和B),当A线程已经锁住了Z，而又去尝试锁住X，而X已经被线程B锁住，线程A和线程B分别持有对应的锁，而又去争夺其他一个锁(尝试锁住另一个线程已经锁住的锁)的时候，就会发生死锁，如下图：

两个线程试图以不同的顺序来获得相同的锁，如果按照相同的顺序来请求锁，那么就不会出现循环的加锁依赖性，因此也就不会产生死锁，每个需要锁Z和锁X的线程都以相同的顺序来获取Z和X，那么就不会发生死锁了，如下图所示：

这样死锁就永远不会发生。针对两个特定的锁，可以尝试按照锁对象的hashCode值大小的顺序，分别获得两个锁，这样锁总是会以特定的顺序获得锁，我们通过设置锁的顺序，来防止死锁的发生，在这里我们使用 System.identityHashCode方法来定义锁的顺序，这个方法将返回由Obejct.hashCode 返回的值，这样就可以消除死锁发生的可能性。

 
 
 
 
      
  
  
  
  1. public class DeadLockExample3 { 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3. // 加时赛锁，在极少数情况下，如果两个hash值相等，使用这个锁进行加锁 
    4.   
  
  
  
  4.  
    5.   
  
  
  
  5. private static final Object tieLock = new Object(); 
    6.   
  
  
  
  6.  
    7.   
  
  
  
  7. public void transferMoney(final Account fromAcct, 
    8.   
  
  
  
  8.  
    9.   
  
  
  
  9. final Account toAcct, 
    10.   
  
  
  
  10.  
    11.   
  
  
  
  11. final DollarAmount amount) 
    12.   
  
  
  
  12.  
    13.   
  
  
  
  13. throws InsufficientFundsException { 
    14.   
  
  
  
  14.  
    15.   
  
  
  
  15. class Helper { 
    16.   
  
  
  
  16.  
    17.   
  
  
  
  17. public void transfer() throws InsufficientFundsException { 
    18.   
  
  
  
  18.  
    19.   
  
  
  
  19. if (fromAcct.getBalance().compareTo(amount) < 0) 
    20.   
  
  
  
  20.  
    21.   
  
  
  
  21. throw new InsufficientFundsException(); 
    22.   
  
  
  
  22.  
    23.   
  
  
  
  23. else { 
    24.   
  
  
  
  24.  
    25.   
  
  
  
  25. fromAcct.debit(amount); 
    26.   
  
  
  
  26.  
    27.   
  
  
  
  27. toAcct.credit(amount); 
    28.   
  
  
  
  28.  
    29.   
  
  
  
  29. } 
    30.   
  
  
  
  30.  
    31.   
  
  
  
  31. } 
    32.   
  
  
  
  32.  
    33.   
  
  
  
  33. } 
    34.   
  
  
  
  34.  
    35.   
  
  
  
  35. // 得到两个锁的hash值 
    36.   
  
  
  
  36.  
    37.   
  
  
  
  37. int fromHash = System.identityHashCode(fromAcct); 
    38.   
  
  
  
  38.  
    39.   
  
  
  
  39. int toHash = System.identityHashCode(toAcct); 
    40.   
  
  
  
  40.  
    41.   
  
  
  
  41. // 根据hash值判断锁顺序，决定锁的顺序 
    42.   
  
  
  
  42.  
    43.   
  
  
  
  43. if (fromHash < toHash) { 
    44.   
  
  
  
  44.  
    45.   
  
  
  
  45. synchronized (fromAcct) { 
    46.   
  
  
  
  46.  
    47.   
  
  
  
  47. synchronized (toAcct) { 
    48.   
  
  
  
  48.  
    49.   
  
  
  
  49. new Helper().transfer(); 
    50.   
  
  
  
  50.  
    51.   
  
  
  
  51. } 
    52.   
  
  
  
  52.  
    53.   
  
  
  
  53. } 
    54.   
  
  
  
  54.  
    55.   
  
  
  
  55. } else if (fromHash > toHash) { 
    56.   
  
  
  
  56.  
    57.   
  
  
  
  57. synchronized (toAcct) { 
    58.   
  
  
  
  58.  
    59.   
  
  
  
  59. synchronized (fromAcct) { 
    60.   
  
  
  
  60.  
    61.   
  
  
  
  61. new Helper().transfer(); 
    62.   
  
  
  
  62.  
    63.   
  
  
  
  63. } 
    64.   
  
  
  
  64.  
    65.   
  
  
  
  65. } 
    66.   
  
  
  
  66.  
    67.   
  
  
  
  67. } else {// 如果两个对象的hash相等，通过tieLock来决定加锁的顺序，否则又会重新引入死锁——加时赛锁 
    68.   
  
  
  
  68.  
    69.   
  
  
  
  69. synchronized (tieLock) { 
    70.   
  
  
  
  70.  
    71.   
  
  
  
  71. synchronized (fromAcct) { 
    72.   
  
  
  
  72.  
    73.   
  
  
  
  73. synchronized (toAcct) { 
    74.   
  
  
  
  74.  
    75.   
  
  
  
  75. new Helper().transfer(); 
    76.   
  
  
  
  76.  
    77.   
  
  
  
  77. } 
    78.   
  
  
  
  78.  
    79.   
  
  
  
  79. } 
    80.   
  
  
  
  80.  
    81.   
  
  
  
  81. } 
    82.   
  
  
  
  82.  
    83.   
  
  
  
  83. } 
    84.   
  
  
  
  84.  
    85.   
  
  
  
  85. } 
    86.   
  
  
  
  86.  
    87.   
  
  
  
  87. } 
    88.
  • 在极少数情况下，两个对象可能拥有两个相同的散列值，此时必须通过某种任意的方法来决定锁的顺序，否则可能又会重新引入死锁。
  • 为了避免这种情况，可以使用 “加时(Tie-Breaking))”锁，这获得这两个Account锁之前，从而消除了死锁发生的可能性

4.3 支持定时的锁(超时放弃)

有一项技术可以检测死锁和从死锁中恢复过来，就是使用Lock类中的定时 publicbooleantryLock(longtime,TimeUnitunit)throwsInterruptedException功能，来代替内置锁机制，当使用内置锁的时候，只要没有获得锁，就会永远等待下去，而 tryLock可以指定一个超时时间 (Timeout)，在等待超过时间后 tryLock会返回一个失败信息，如果超时时限比获取锁的时间要长很多，那么就可以在发生某个意外后重新获得控制权。如下图所示：

4.4 死锁避免

死锁防止方法能够防止发生死锁，但必然会降低系统并发性，导致低效的资源利用率，其中最具有代表性的避免死锁算法是银行家算法。

1、多个资源的银行家算法

上图中有五个进程，四个资源。左边的图表示已经分配的资源，右边的图表示还需要分配的资源。最右边的 E、P 以及 A 分别表示：总资源、已分配资源以及可用资源，注意这三个为向量，而不是具体数值，例如 A=(1020)，表示 4 个资源分别还剩下 1/0/2/0。

检查一个状态是否安全的算法如下：

  • 查找右边的矩阵是否存在一行小于等于向量 A。如果不存在这样的行，那么系统将会发生死锁，状态是不安全的。
  • 假若找到这样一行，将该进程标记为终止，并将其已分配资源加到 A 中。
  • 重复以上两步，直到所有进程都标记为终止，则状态是安全的。
  • 如果一个状态不是安全的，需要拒绝进入这个状态。

4.5 死锁检测

  • 对资源的分配加以适当限制可防止或避免死锁发生，但不利于进程对系统资源的充分共享。
  • 为每个进程和每个资源指定一个唯一的号码
  • Jstack命令 jstack用于生成java虚拟机当前时刻的线程快照。线程快照是当前java虚拟机内每一条线程正在执行的方法堆栈的集合，生成线程快照的主要目的是定位线程出现长时间停顿的原因，如线程间死锁、死循环、请求外部资源导致的长时间等待，线程出现停顿的时候通过jstack来查看各个线程的调用堆栈，就可以知道没有响应的线程到底在后台做什么事情，或者等待什么资源
  • JConsole工具

Jconsole是JDK自带的监控工具，在JDK/bin目录下可以找到。它用于连接正在运行的本地或者

远程的JVM，对运行在Java应用程序的资源消耗和性能进行监控，并画出大量的图表，提供强大

的可视化界面。而且本身占用的服务器内存很小，甚至可以说几乎不消耗。

4.5 死锁恢复

  • 资源剥夺：剥夺陷于死锁的进程所占用的资源，但并不撤销此进程，直至死锁解除
  • 进程回退：根据系统保存的检查点让所有的进程回退，直到足以解除死锁，这种措施要求系统建立保存检查点、回退及重启机制
  • 进程撤销：

1、撤销陷入死锁的所有进程，解除死锁，继续运行。

2、逐个撤销陷入死锁的进程，回收其资源并重新分配，直至死锁解除。 可选择符合下面条件之一的先撤销：

  1. CPU消耗时间最少者
  2. 产生的输出量最小者
  3. 预计剩余执行时间最长者
  4. 分得的资源数量最少者后优先级最低者

系统重启：结束所有进程的执行并重新启动操作系统。这种方法很简单，但先前的工作全部作废。

分享文章：一篇带给你多线程死锁详解
文章网址：http://www.shufengxianlan.com/qtweb/news30/555780.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

商城网站知识

同城分类信息

成都网站建设推广　　 　网站建设公司　　 　网站营销推广　　 　域名注册　　 　支点广告　　 　成都网站托管　　 　鼎尚理发店　　 　四川搅拌罐车　　 　3D立体画　　 　成都温江机房　　 　江油做网站　　 　重庆建站　　 　网络营销公司　　 　成都网站制作　　 　成都小程序　　 　商城网站建设公司　　 　网络营销推广　　 　成都租用服务器　　 　简阳机房托管　　 　机柜租用