乐趣区

关于java:如何排查Java应用的死锁

jiezi

如何结构一个死锁呢? 很简略，只有让线程 1 占有对象 a 的锁后，再去申请对象 b 的锁。与此同时，对象 2 曾经占有了对象 b 的锁，再申请对象 a 的锁。线程 1 与线程 2 相互期待，造成了死锁。(在面试中，也会被常常地要求手写死锁)

首先，咱们结构一个死锁场景。

如何结构一个死锁呢?

很简略，只有让线程 1 占有对象 a 的锁后，再去申请对象 b 的锁。与此同时，对象 2 曾经占有了对象 b 的锁，再申请对象 a 的锁。线程 1 与线程 2 相互期待，造成了死锁。(在面试中，也会被常常地要求手写死锁)

代码如下：

  1. package com.example.dl;
  2. import org.springframework.web.bind.annotation.RequestMapping;
  3. import org.springframework.web.bind.annotation.RestController;
  4. @RestController
  5. public class Controller {
  6. @RequestMapping(“/test”)
  7. public String testDeadLock() {
  8. final Object a = new Object();
  9. final Object b = new Object();
  10. new Thread(() -> {
  11. synchronized (a) {
  12. System.out.println(Thread.currentThread().getName() + “ 占有了对象 a 的锁 ”);
  13. try {
  14. Thread.sleep(1000);
  15. } catch (InterruptedException e) {
  16. e.printStackTrace();
  17. }
  18. System.out.println(Thread.currentThread().getName() + “ 申请对象 b 的锁 ”);
  19. synchronized (b) {
  20. System.out.println(Thread.currentThread().getName() + “ 占有了对象 b 的锁 ”);
  21. }
  22. }
  23. }, “Thread 1”).start();
  24. new Thread(() -> {
  25. synchronized (b) {
  26. System.out.println(Thread.currentThread().getName() + “ 占有了对象 b 的锁 ”);
  27. try {
  28. Thread.sleep(1000);
  29. } catch (InterruptedException e) {
  30. e.printStackTrace();
  31. }
  32. System.out.println(Thread.currentThread().getName() + “ 申请对象 a 的锁 ”);
  33. synchronized (a) {
  34. System.out.println(Thread.currentThread().getName() + “ 占有了对象 a 的锁 ”);
  35. }
  36. }
  37. }, “Thread 2”).start();
  38. return “success”;
  39. }
  40. }

输入如下：

如果不施加干涉，两个线程将会始终僵持着。

这个只是一个简略的死锁场景，如果线上产生这样的状况，该去如何定位呢?

咱们把死锁代码放进一个简略的 SpringBoot 中

应用 mvn install 打包后，将打好的 jar 包放进咱们试验的机器中，我的项目名称就叫做 dl

应用nohup java -jar dl-0.0.1-SNAPSHOT.jar & 部署运行

应用 curl http:port/test 调用接口，不出意外的话，当初程序产生了死锁。

首先获取到该 java 利用的过程，ps -ef | grep dl | grep -v grep，获取到 pid 为 12156

接着打印出该过程下线程的状态，并输入到dl.txt 中，jstack 12156 > dl.txt

jstack 能够用来生成虚拟机以后的线程快照，疾速定位多线程使用不当引发的问题。

在该 txt 文件的开端，咱们能够看到以下的内容：

  1. Found one Java-level deadlock:
  2. =============================
  3. “Thread 2”:
  4. waiting to lock monitor 0x00007f9ea8006008 (object 0x00000000e367d550, a java.lang.Object),
  5. which is held by “Thread 1”
  6. “Thread 1”:
  7. waiting to lock monitor 0x00007f9ea8003f08 (object 0x00000000e367d560, a java.lang.Object),
  8. which is held by “Thread 2”
  9. Java stack information for the threads listed above:
  10. ===================================================
  11. “Thread 2”:
  12. at com.example.dl.Controller.lambda$testDeadLock$1(Controller.java:40)
  13. – waiting to lock <0x00000000e367d550> (a java.lang.Object)
  14. – locked <0x00000000e367d560> (a java.lang.Object)
  15. at com.example.dl.Controller$$Lambda$469/1627217364.run(Unknown Source)
  16. at java.lang.Thread.run(Thread.java:748)
  17. “Thread 1”:
  18. at com.example.dl.Controller.lambda$testDeadLock$0(Controller.java:25)
  19. – waiting to lock <0x00000000e367d560> (a java.lang.Object)
  20. – locked <0x00000000e367d550> (a java.lang.Object)
  21. at com.example.dl.Controller$$Lambda$468/117875601.run(Unknown Source)
  22. at java.lang.Thread.run(Thread.java:748)
  23. Found 1 deadlock.

能够清晰地看到，Thread 2 申请一把被 Thread 1 占有的锁，而 Thread 1 申请一把被 Thread 2 占有的锁，这样就形成了死锁。

当然，这个场景十分的简略，然而线上环境盘根错节，在接口响应越来越慢、cpu 负载越来越高的时候，能够应用 jstack 命令，查看 java 过程内线程的状态，看是否有死循环、死锁等。

而后依据具体情况具体分析，比方说依照程序取得对象的锁，只能是从 a 到 b 的程序，线程 1 获取 a 对象的锁后，尝试去获取 b 对象的锁时，线程 2 想要间接获取 b 对象的锁，则首先要获取对象 a 的锁，从而被线程 1 阻塞，等到线程 1 运行完结，开释所有的锁后，线程 2 才能够持续运行。

或者说 超时间接放弃，换 synchronized 为 ReentranLock，应用其带有工夫的 tryLock 办法，肯定工夫内获取不到锁，间接放弃本次对锁的申请。

退出移动版