死锁？如何定位到死锁？如何修复死锁？

一、死锁的概念

两个或多个线程之间，由于互相持有对方需要的锁，而永久处于阻塞的状态。

我们来看一个容易造成死锁场景的例子：

@Slf4j
public class DeadLockThread implements Runnable {
    private String lockA;
    private String lockB;

    public DeadLockThread(String threadName, String lockA, String lockB) {
        this.lockA = lockA;
        this.lockB = lockB;
    }

    @Override
    public void run() {
        synchronized (lockA) {
            log.info("{} 获取了{}", Thread.currentThread().getName(), lockA);
            try {
                Thread.sleep(1000L);
                synchronized (lockB) {
                    log.info("{} 获取了{}", Thread.currentThread().getName(), lockB);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

    public static void main(String[] args) {
        String lockA = "lockA";
        String lockB = "lockB";

        // 让t1线程先获取lockA，再获取lockB
        Thread t1 = new Thread(new DeadLockThread("Thread1", lockA, lockB));
        // 让t1线程先获取lockB，再获取lockA
        Thread t2 = new Thread(new DeadLockThread("Thread2", lockB, lockA));

        t1.start();
        t2.start();
    }

当我们启动上述代码后，几乎每次都会进入死锁的状态，即程序一直的得不到结束，但是我们怎么确定程序就是进入了死锁状态呢？

二、死锁问题的定位

2.1 使用jstack工具

jdk中提供了jps和jstack两个工具，先jps查看进程ID，然后jstack查看异常未结束的进程信息；通过信息进一步分析代码问题；如下是对如上例子中的进程pid进行jstack分析的结论：

Found one Java-level deadlock:
=============================
"Thread-1":
  waiting to lock monitor 0x000000001ccb11e8 (object 0x000000076b387cd8, a java.lang.String),
  which is held by "Thread-0"
"Thread-0":
  waiting to lock monitor 0x000000001ccb2f78 (object 0x000000076b387d10, a java.lang.String),
  which is held by "Thread-1"

Java stack information for the threads listed above:
===================================================
"Thread-1":
        at cn.paic.zhangxun.restdemo.deadlock.DeadLockThread.run(DeadLockThread.java:26)
        - waiting to lock <0x000000076b387cd8> (a java.lang.String)
        - locked <0x000000076b387d10> (a java.lang.String)
        at java.lang.Thread.run(Thread.java:745)
"Thread-0":
        at cn.paic.zhangxun.restdemo.deadlock.DeadLockThread.run(DeadLockThread.java:26)
        - waiting to lock <0x000000076b387d10> (a java.lang.String)
        - locked <0x000000076b387cd8> (a java.lang.String)
        at java.lang.Thread.run(Thread.java:745)

Found 1 deadlock.

可以看到，jstack分析结果中明确指出了发生了deadlock现象，并且指出来了thead0和thread1两个线程发生了互相持有和等待对方需要的资源的死锁情况。

2.2 使用标准API扫描

使用Java提供的标准管理API，ThreadMXBean，其有findDeadlockedThreads方法可以找到死锁的地方；

    public static void main(String[] args) {
        ThreadMXBean mxBean = ManagementFactory.getThreadMXBean();
        Runnable deadlockCheck = () -> {
          long[] threadIds = mxBean.findDeadlockedThreads();
          if(threadIds != null){
              ThreadInfo[] threadInfos = mxBean.getThreadInfo(threadIds);
              log.warn("发现死锁线程！！！");
              for(ThreadInfo threadInfo:threadInfos){
                  log.info("死锁线程ID是{},名称是{}",threadInfo.getThreadId(), threadInfo.getThreadName());
              }
          }else{
              log.info("当前未扫描到死锁线程......");
          }
        };

        ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(1);
        // 第一次等2秒，后续每5秒扫描一次
        scheduledExecutorService.scheduleAtFixedRate(deadlockCheck, 2L, 5L, TimeUnit.SECONDS);
    }

该方法并没有检测到上述例子中的死锁，具体问题待以后确认。

2.3 代码扫描和代码评审

可以使用一些静态代码扫描工具，比如sonarlint、findbugs等进行代码的静态扫描；

同时加强代码评审，请有并发经验的同事一块看下。

三、如何修复死锁

绝大多数死锁问题都是无法在线解决的，只能找到程序问题之后重新发布解决。

四、如何避免死锁

首先，我们需要知道产生死锁的四个必要条件：

• 互斥；资源（锁）同一时间只能被一个线程使用；
• 占有且等待；一个线程占用资源后，等待获取别的资源；
• 不可抢占；线程已占有的资源自身不释放时别的线程不能抢占；
• 循环等待；每个线程都占用别的线程需要的资源并等待；

只要打破以上四个条件中的一个，死锁就不会发生了：

• 尽量避免使用多个锁，并且只有需要时才持有锁，用完立即释放锁；嵌套的synchronized或者lock会非常容易导致问题；
• 尽量设计好获取锁的顺序，使之不会出现相互持有和等待对方锁的情况；
• 使用带超时的获取锁的方法；