1、死锁发生的条件

  • 互斥
  • 环路
  • 请求并保持
  • 不可剥夺

2、死锁的影响

死锁在不同系统中是不一样的，这取决于系统对死锁的处理能力

  • 数据库：检测并放弃事务

  • jvm中：无法自动处理

3、发生死锁的例子

两个线程相互持有并等待锁

  1. /**
  2.  * @Author: zhangjx
  3.  * @Date: 2020/9/20 19:27
  4.  * @Description: 必定发生死锁的例子
  5.  */
  6. public class MustDeadLock implements Runnable{
  7.     int falg = 1;
  9.     static Object o1 = new Object();
  10.     static Object o2 = new Object();
  12.     @Override
  13.     public void run() {
  14.         if (falg == 1) {
  15.             synchronized (o1){
  16.                 System.out.println("获取o1的锁");
  17.                 try {
  18.                     Thread.sleep(1000);
  19.                 } catch (InterruptedException e) {
  20.                     e.printStackTrace();
  21.                 }
  22.                 synchronized (o2){
  23.                     System.out.println("获取o2的锁");
  24.                 }
  25.             }
  26.         }
  28.         if (falg == 0) {
  29.             synchronized (o2){
  30.                 System.out.println("获取o2的锁");
  31.                 try {
  32.                     Thread.sleep(1000);
  33.                 } catch (InterruptedException e) {
  34.                     e.printStackTrace();
  35.                 }
  36.                 synchronized (o1){
  37.                     System.out.println("获取o1的锁");
  38.                 }
  39.             }
  40.         }
  41.     }
  43.     public static void main(String[] args) {
  44.         MustDeadLock runnable1 = new MustDeadLock();
  45.         runnable1.falg = 0;
  46.         MustDeadLock runnable2 = new MustDeadLock();
  47.         runnable2.falg = 1;
  48.         new Thread(runnable1).start();
  49.         new Thread(runnable2).start();
  50.     }
  51. }

4、如何定位死锁

4.1 jstack(不是一定能检测出来)

1、查看java的pid
2、执行${JAVA_HOME}/bin/jstack pid

  1. Found one Java-level deadlock:
  2. =============================
  3. "Thread-1":
  4.   waiting to lock monitor 0x000000002881fa38 (object 0x0000000716cdd788, a java.lang.Object),
  5.   which is held by "Thread-0"
  6. "Thread-0":
  7.   waiting to lock monitor 0x00000000259f0c88 (object 0x0000000716cdd778, a java.lang.Object),
  8.   which is held by "Thread-1"
  10. Java stack information for the threads listed above:
  11. ===================================================
  12. "Thread-1":
  13.         at com.imooc.thread_demo.deadlock.MustDeadLock.run(MustDeadLock.java:25)
  14.         - waiting to lock <0x0000000716cdd788> (a java.lang.Object)
  15.         - locked <0x0000000716cdd778> (a java.lang.Object)
  16.         at java.lang.Thread.run(Thread.java:748)
  17. "Thread-0":
  18.         at com.imooc.thread_demo.deadlock.MustDeadLock.run(MustDeadLock.java:39)
  19.         - waiting to lock <0x0000000716cdd778> (a java.lang.Object)
  20.         - locked <0x0000000716cdd788> (a java.lang.Object)
  21.         at java.lang.Thread.run(Thread.java:748)
  23. Found 1 deadlock.

2、ThreadMXBean 代码

  1. package com.imooc.thread_demo.deadlock;
  3. import java.lang.management.ManagementFactory;
  4. import java.lang.management.ThreadInfo;
  5. import java.lang.management.ThreadMXBean;
  6. import java.util.Arrays;
  8. /**
  9.  * @Author: zhangjx
  10.  * @Date: 2020/9/20 21:14
  11.  * @Description:
  12.  */
  13. public class QryDeadLock implements Runnable{
  14.     int falg = 1;
  16.     static Object o1 = new Object();
  17.     static Object o2 = new Object();
  19.     @Override
  20.     public void run() {
  21.         if (falg == 1) {
  22.             synchronized (o1) {
  23.                 System.out.println("获取o1的锁");
  24.                 try {
  25.                     Thread.sleep(1000);
  26.                 } catch (InterruptedException e) {
  27.                     e.printStackTrace();
  28.                 }
  29.                 synchronized (o2) {
  30.                     System.out.println("获取o2的锁");
  31.                 }
  32.             }
  33.         }
  35.         if (falg == 0) {
  36.             synchronized (o2) {
  37.                 System.out.println("获取o2的锁");
  38.                 try {
  39.                     Thread.sleep(1000);
  40.                 } catch (InterruptedException e) {
  41.                     e.printStackTrace();
  42.                 }
  43.                 synchronized (o1) {
  44.                     System.out.println("获取o1的锁");
  45.                 }
  46.             }
  47.         }
  48.     }
  49.     public static void main(String[] args) throws InterruptedException {
  50.         QryDeadLock runnable1 = new QryDeadLock();
  51.         runnable1.falg = 0;
  52.         QryDeadLock runnable2 = new QryDeadLock();
  53.         runnable2.falg = 1;
  54.         new Thread(runnable1).start();
  55.         new Thread(runnable2).start();
  56.         Thread.sleep(1000);
  57.         ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
  58.         long[] deadlockedThreads = threadMXBean.findDeadlockedThreads();
  59.         if(deadlockedThreads != null && deadlockedThreads.length > 0){
  60.             Arrays.stream(deadlockedThreads).forEach(e -> {
  61.                 ThreadInfo threadInfo = threadMXBean.getThreadInfo(e);
  62.                 System.out.println("发现死锁 ：" + threadInfo.getThreadName() + " " + threadInfo.getLockName());
  63.             });
  64.         }
  66.     }
  67. }

5、如何修复死锁

1、避免策略
避免相反获取锁顺序的发生，用hash值决定两把锁获取的顺序
2、检测与恢复策略
一段时间检测是否有死锁，如果有就剥夺某个资源，打开死锁
3、鸵鸟策略（不处理）

6、实际工程中如何避免死锁

1、设置超时时间

Lock的tryLock(Long timeOut,TimeUnit unit)
syncronized不具备尝试锁的能力

获取锁失败：打日志，发邮件报警，重启等

  1. package com.imooc.thread_demo.deadlock;
  3. import java.util.concurrent.TimeUnit;
  4. import java.util.concurrent.locks.Lock;
  5. import java.util.concurrent.locks.ReentrantLock;
  7. /**
  8.  * @Author: zhangjx
  9.  * @Date: 2020/9/20 22:14
  10.  * @Description: 设置超时时间解决死锁
  11.  */
  12. public class TryLockDeadLock implements Runnable{
  13.     static Lock lock1 = new ReentrantLock();
  14.     static Lock lock2 = new ReentrantLock();
  16.      int flag = 0;
  18.     public static void main(String[] args) {
  19.         TryLockDeadLock runnable1 = new TryLockDeadLock();
  20.         runnable1.flag = 0;
  21.         TryLockDeadLock runnable2 = new TryLockDeadLock();
  22.         runnable2.flag = 1;
  23.         new Thread(runnable1).start();
  24.         new Thread(runnable2).start();
  25.     }
  27.     @Override
  28.     public void run() {
  29.         for (int i = 0; i < 10; i++) {
  30.             if (flag == 1) {
  31.                 try {
  32.                     if(lock1.tryLock(1000, TimeUnit.MILLISECONDS)){
  33.                         System.out.println("线程1获取到第一把锁lock1");
  34.                         if(lock2.tryLock(1100, TimeUnit.MILLISECONDS)){
  35.                             System.out.println("线程1获取到两把锁，lock1，lock2");
  36.                             Thread.sleep(2000);
  37.                             System.out.println("线程1执行完毕，退出");
  38.                             lock2.unlock();
  39.                             lock1.unlock();
  40.                             break;
  41.                         }else {
  42.                             System.out.println("线程1获取第二把锁lock2失败,释放第一把锁lock1，重试");
  43.                             lock1.unlock();
  44.                         }
  45.                     }else {
  46.                         System.out.println("线程1获取第一把锁lock1失败,重试");
  47.                     }
  48.                 } catch (InterruptedException ex) {
  49.                     ex.printStackTrace();
  50.                 }
  51.             }
  53.             if (flag == 0) {
  54.                 try {
  55.                     if(lock2.tryLock(800, TimeUnit.MILLISECONDS)){
  56.                         System.out.println("线程2获取到第一把锁lock2");
  57.                         if(lock1.tryLock(900, TimeUnit.MILLISECONDS)){
  58.                             System.out.println("线程2获取到两把锁 lock2，lock1");
  59.                             Thread.sleep(1000);
  60.                             System.out.println("线程2执行完毕，退出");
  61.                             lock1.unlock();
  62.                             lock2.unlock();
  63.                             break;
  64.                         }else {
  65.                             System.out.println("线程2获取第二把锁lock1失败,释放第一把锁lock2，重试");
  66.                             lock2.unlock();
  67.                         }
  68.                     }else {
  69.                         System.out.println("线程2获取第一把锁释放第一把锁lock2失败,已重试");
  70.                     }
  71.                 } catch (InterruptedException ex) {
  72.                     ex.printStackTrace();
  73.                 }
  74.             }
  75.         }
  77.     }
  78. }

2、多使用并发类，而不是自己去设计锁

  • ConcurrentLinkedDeque ，ConcurrentHashMap等
  • 实际应用中java.util.concurrent.atomic简单方便且效率比使用lock更高
  • 多使用并发集合少使用同步集合

3、尽量降低锁的使用粒度，用不同的锁而不是一个锁

4、尽量使用同步代码块代替同步方法，自己指定锁对象

5、给线程取有意义的名字

6、避免锁的嵌套

7、分配资源前看是否能够收回来，银行家算法

8、尽量不要不同功能使用同一个锁