如何排查Java应用的死锁

开发 后端
如何构造一个死锁呢?很简单,只要让线程1占有对象a的锁后,再去请求对象b的锁。与此同时,对象2已经占有了对象b的锁,再请求对象a的锁。线程1与线程2互相等待,形成了死锁。(在面试中,也会被经常地要求手写死锁)

[[384794]]

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

如何构造一个死锁呢?

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

代码如下:

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

 输出如下:


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

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

我们把死锁代码放进一个简单的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.  
  10. Java stack information for the threads listed above: 
  11. =================================================== 
  12. "Thread 2"
  13.     at com.example.dl.Controller.lambda$testDeadLock$1(Controller.java:40) 
  14.     - waiting to lock <0x00000000e367d550> (a java.lang.Object) 
  15.     - locked <0x00000000e367d560> (a java.lang.Object) 
  16.     at com.example.dl.Controller$$Lambda$469/1627217364.run(Unknown Source) 
  17.     at java.lang.Thread.run(Thread.java:748) 
  18. "Thread 1"
  19.     at com.example.dl.Controller.lambda$testDeadLock$0(Controller.java:25) 
  20.     - waiting to lock <0x00000000e367d560> (a java.lang.Object) 
  21.     - locked <0x00000000e367d550> (a java.lang.Object) 
  22.     at com.example.dl.Controller$$Lambda$468/117875601.run(Unknown Source) 
  23.     at java.lang.Thread.run(Thread.java:748) 
  24.  
  25. 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方法,一定时间内获取不到锁,直接放弃本次对锁的申请。

 

责任编辑:姜华 来源: 今日头条
相关推荐

2017-10-18 15:07:21

MySQL执行死锁

2023-02-16 08:10:40

死锁线程

2022-05-16 07:35:47

死锁工具jstack

2021-08-24 08:01:15

死锁工具多线编程

2019-03-15 16:20:45

MySQL死锁排查命令

2023-07-26 07:18:54

死锁线程池

2015-03-18 09:21:53

编程Java死锁

2022-10-13 08:02:13

死锁运算系统

2017-12-19 14:00:16

数据库MySQL死锁排查

2009-06-12 16:15:42

死锁Java虚拟机

2022-05-13 23:46:52

GO编程内存

2016-10-20 15:27:18

MySQLredo死锁

2021-10-14 07:28:03

Kubernetes通用排查

2010-03-16 18:06:29

Java线程死锁

2021-03-02 10:11:13

MySQL死锁数据库

2019-04-15 13:15:12

数据库MySQL死锁

2010-08-30 19:51:08

DHCP故障

2021-06-28 08:00:00

Python开发编程语言

2021-10-20 20:27:55

MySQL死锁并发

2009-06-29 15:23:00

点赞
收藏

51CTO技术栈公众号