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

一、死锁的概念

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

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

@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会非常容易导致问题;
  • 尽量设计好获取锁的顺序,使之不会出现相互持有和等待对方锁的情况;
  • 使用带超时的获取锁的方法;

你可能感兴趣的:(死锁?如何定位到死锁?如何修复死锁?)