如何排查Java应用的死锁

 首先，我们构造一个死锁场景。

十多年的碧江网站建设经验，针对设计、前端、开发、售后、文案、推广等六对一服务，响应快，48小时及时工作处理。营销型网站建设的优势是能够根据用户设备显示端的尺寸不同，自动调整碧江建站的显示方式，使网站能够适用不同显示终端，在浏览器中调整网站的宽度，无论在任何一种浏览器上浏览网站，都能展现优雅布局与设计，从而大程度地提升浏览体验。创新互联建站从事“碧江网站设计”,“碧江网站推广”以来，每个客户项目都认真落实执行。

如何构造一个死锁呢?

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

代码如下：

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

 输出如下：

如果不施加干预，两个线程将会一直僵持着。

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

我们把死锁代码放进一个简单的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. 
  
  
  
  
  2. =============================
    3. 
  
  
  
  
  3. "Thread 2":
    4. 
  
  
  
  
  4.   waiting to lock monitor 0x00007f9ea8006008 (object 0x00000000e367d550, a java.lang.Object),
    5. 
  
  
  
  
  5.   which is held by "Thread 1"
    6. 
  
  
  
  
  6. "Thread 1":
    7. 
  
  
  
  
  7.   waiting to lock monitor 0x00007f9ea8003f08 (object 0x00000000e367d560, a java.lang.Object),
    8. 
  
  
  
  
  8.   which is held by "Thread 2"
    9. 
  
  
  
  
  9. 
  
  
  
  
  10. Java stack information for the threads listed above:
    11. 
  
  
  
  
  11. ===================================================
    12. 
  
  
  
  
  12. "Thread 2":
    13. 
  
  
  
  
  13.     at com.example.dl.Controller.lambda$testDeadLock$1(Controller.java:40)
    14. 
  
  
  
  
  14.     - waiting to lock <0x00000000e367d550> (a java.lang.Object)
    15. 
  
  
  
  
  15.     - locked <0x00000000e367d560> (a java.lang.Object)
    16. 
  
  
  
  
  16.     at com.example.dl.Controller$$Lambda$469/1627217364.run(Unknown Source)
    17. 
  
  
  
  
  17.     at java.lang.Thread.run(Thread.java:748)
    18. 
  
  
  
  
  18. "Thread 1":
    19. 
  
  
  
  
  19.     at com.example.dl.Controller.lambda$testDeadLock$0(Controller.java:25)
    20. 
  
  
  
  
  20.     - waiting to lock <0x00000000e367d560> (a java.lang.Object)
    21. 
  
  
  
  
  21.     - locked <0x00000000e367d550> (a java.lang.Object)
    22. 
  
  
  
  
  22.     at com.example.dl.Controller$$Lambda$468/117875601.run(Unknown Source)
    23. 
  
  
  
  
  23.     at java.lang.Thread.run(Thread.java:748)
    24. 
  
  
  
  
  24. 
  
  
  
  
  25. Found 1 deadlock.
    26.

 可以清晰地看到，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方法，一定时间内获取不到锁，直接放弃本次对锁的申请。

网站栏目：如何排查Java应用的死锁
分享路径：http://www.shufengxianlan.com/qtweb/news32/25532.html

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

广告

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

猜你还喜欢下面的内容

网站制作知识

同城分类信息

定制网站建设多少钱　　 　成都网站改版　　 　成都婚庆策划　　 　成都网站设计　　 　南充服务器托管　　 　网站建设方案　　 　网站设计　　 　班戈纳美网站　　 　成都网站优化　　 　3D立体画　　 　成都网站营销　　 　App开发　　 　腾讯云虚拟主机　　 　资阳网站建设　　 　成都做网站　　 　成都网站制作　　 　四川门窗　　 　草坪音箱　　 　软文营销　　 　梓潼网站制作公司