死锁定位解决

最新推荐文章于 2025-06-14 13:43:09 发布
原创 最新推荐文章于 2025-06-14 13:43:09 发布 · 3.8k 阅读 · 4 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #开发语言

本文介绍了Java中死锁的概念、原因及四个必要条件，通过实例展示了如何使用jstack和Arthas工具定位死锁，并提出了预防死锁的措施，包括合理分配资源和设置锁获取顺序等。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

死锁

死锁：是指两个或两个以上的进程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。

死锁发生的原因

死锁的发生是由于资源竞争导致的，导致死锁的原因如下：

  • 系统资源不足，如果系统资源充足，死锁出现的可能性就很低。
  • 进程（线程）运行推进的顺序不合适。
  • 资源分配不当等。

死锁发生的条件

死锁的发生的四个必要条件：

  1. 互斥条件：一个资源每次只能被一个进程使用。
  2. 占有且等待：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
  3. 不可强行占有：进程（线程）已获得的资源，在未使用完之前，不能强行剥夺。
  4. 循环等待条件：若干进程（线程）之间形成一种头尾相接的循环等待资源关系。

这四个条件是死锁的必要条件，只要系统发生死锁，这些条件必然成立，而只要上述条件之一不满足，就不会发生死锁。

1：通过jstack定位死锁信息

1.1：编写死锁代码

Lock lock1 = new ReentrantLock();
  Lock lock2 = new ReentrantLock();
  
  ExecutorService exectuorService = Executors.newFixedThreadPool(2);
  
  exectuorService.submit(() -> {
     lock1.lock();
     try{
         Thread.sleep(1000);
     }catch(Exception e){}
     try{}
     finally{
       lock1.unlock();
       lock2.unlock();
     }
  });
  exectuorService.submit(() -> {
     lock2.lock();
     try{
        Thread.sleep(1000);
     }catch(Exception e){}
     
     try{}
     finally{
         lock1.unlock();
         lock2.unlock();
     }
  });

1.2：查看死锁线程的pid

  • jps查看死锁的线程pid
  • 使用 jstack -l pid 查看死锁信息
  • 通过打印信息我们可以找到发生死锁的代码是在哪个位置

 

"DestroyJavaVM" #13 prio=5 os_prio=31 tid=0x00007f9a1d8fe800 nid=0xd03 waiting on condition [0x0000000000000000]
   java.lang.Thread.State: RUNNABLE

   Locked ownable synchronizers:
 - None

"pool-1-thread-2" #12 prio=5 os_prio=31 tid=0x00007f9a1d8fe000 nid=0xa703 waiting on condition [0x000070000ff8e000]
   java.lang.Thread.State: WAITING (parking)
 at sun.misc.Unsafe.park(Native Method)
 - parking to wait for  <0x0000000795768cd8> (a java.util.concurrent.locks.ReentrantLock$NonfairSync)
 at java.util.concurrent.locks.LockSupport.park(LockSupport.java:175)
 at java.util.concurrent.locks.AbstractQueuedSynchronizer.parkAndCheckInterrupt(AbstractQueuedSynchronizer.java:836)
 at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireQueued(AbstractQueuedSynchronizer.java:870)
 at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquire(AbstractQueuedSynchronizer.java:1199)
 at java.util.concurrent.locks.ReentrantLock$NonfairSync.lock(ReentrantLock.java:209)
 at java.util.concurrent.locks.ReentrantLock.lock(ReentrantLock.java:285)
 at com.coco.util.SlideTimeUnit.lambda$main$1(SlideTimeUnit.java:63)
 at com.coco.util.SlideTimeUnit$$Lambda$2/565760380.run(Unknown Source)
 at java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:511)
 at java.util.concurrent.FutureTask.run(FutureTask.java:266)
 at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)
 at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
 at java.lang.Thread.run(Thread.java:748)

   Locked ownable synchronizers:
 - <0x0000000795768d08> (a java.util.concurrent.locks.ReentrantLock$NonfairSync)
 - <0x0000000795a9e4e0> (a java.util.concurrent.ThreadPoolExecutor$Worker)

"pool-1-thread-1" #11 prio=5 os_prio=31 tid=0x00007f9a2082c800 nid=0xa803 waiting on condition [0x000070000fe8b000]
   java.lang.Thread.State: WAITING (parking)
 at sun.misc.Unsafe.park(Native Method)
 - parking to wait for  <0x0000000795768d08> (a java.util.concurrent.locks.ReentrantLock$NonfairSync)
 at java.util.concurrent.locks.LockSupport.park(LockSupport.java:175)
 at java.util.concurrent.locks.AbstractQueuedSynchronizer.parkAndCheckInterrupt(AbstractQueuedSynchronizer.java:836)
 at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireQueued(AbstractQueuedSynchronizer.java:870)
 at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquire(AbstractQueuedSynchronizer.java:1199)
 at java.util.concurrent.locks.ReentrantLock$NonfairSync.lock(ReentrantLock.java:209)
 at java.util.concurrent.locks.ReentrantLock.lock(ReentrantLock.java:285)
 at com.coco.util.SlideTimeUnit.lambda$main$0(SlideTimeUnit.java:49)
 at com.coco.util.SlideTimeUnit$$Lambda$1/596512129.run(Unknown Source)
 at java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:511)
 at java.util.concurrent.FutureTask.run(FutureTask.java:266)
 at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)
 at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
 at java.lang.Thread.run(Thread.java:748)

   Locked ownable synchronizers:
 - <0x0000000795768cd8> (a java.util.concurrent.locks.ReentrantLock$NonfairSync)
 - <0x0000000795a9ba28> (a java.util.concurrent.ThreadPoolExecutor$Worker)

"Service Thread" #10 daemon prio=9 os_prio=31 tid=0x00007f9a2082c000 nid=0x4103 runnable [0x0000000000000000]
   java.lang.Thread.State: RUNNABLE

   Locked ownable synchronizers:
 - None

"C1 CompilerThread3" #9 daemon prio=9 os_prio=31 tid=0x00007f9a1e021800 nid=0x3f03 waiting on condition [0x0000000000000000]
   java.lang.Thread.State: RUNNABLE

2：通过Arthas工具定位死锁

2.1: 下载好Arthas的jar,然后运行

有一个 thread -b 就可以查看到死锁信息

[arthas@4182]$ thread -b
"pool-1-thread-2" Id=12 WAITING on java.util.concurrent.locks.ReentrantLock$NonfairSync@2cb8a9a3 owned by "pool-1-thread-1" Id=11
    at sun.misc.Unsafe.park(Native Method)
    -  waiting on java.util.concurrent.locks.ReentrantLock$NonfairSync@2cb8a9a3
    at java.util.concurrent.locks.LockSupport.park(LockSupport.java:175)
    at java.util.concurrent.locks.AbstractQueuedSynchronizer.parkAndCheckInterrupt(AbstractQueuedSynchronizer.java:836)
    at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireQueued(AbstractQueuedSynchronizer.java:870)
    at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquire(AbstractQueuedSynchronizer.java:1199)
    at java.util.concurrent.locks.ReentrantLock$NonfairSync.lock(ReentrantLock.java:209)
    at java.util.concurrent.locks.ReentrantLock.lock(ReentrantLock.java:285)
    at com.coco.util.SlideTimeUnit.lambda$main$1(SlideTimeUnit.java:63)
    at com.coco.util.SlideTimeUnit$$Lambda$2/565760380.run(Unknown Source)
    at java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:511)
    at java.util.concurrent.FutureTask.run(FutureTask.java:266)
    at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)
    at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
    at java.lang.Thread.run(Thread.java:748)

    Number of locked synchronizers = 2
    - java.util.concurrent.ThreadPoolExecutor$Worker@6433a2
    - java.util.concurrent.locks.ReentrantLock$NonfairSync@3a855d13 <---- but blocks 1 other threads!

3. 通过 Jvisualvm 定位死锁

Jvisualvm 是一种自带的可视化工具，往往在在本地执行。

通过 Jvisualvm 命令打开软件，选中进程，进入线程视图，会给出死锁提示:

死锁的预防

  • 尽量避免使用多个锁，并且只有需要时才持有锁。
  • 如果使用多个锁，一定要设计好锁的获取顺序。
  • 使用带有超时的方法，为程序带来更多的可控性，比如指定获取锁的时间最多为5秒，超时就放弃。
  • 通过一些代码静态检查工具发现可能存在的死锁问题，比如FindBugs。

 

线程死锁的成因？如何查找并定位死锁，解决死锁？这里教你几招~
CYK_byte的博客
09-27 1924
死锁就是指线程t1要使用的资源被线程t2占用，线程t2想使用的资源被线程 t1占用，这就像两股绳子拧在一起，解不开了；
【Oracle数据库死锁检查与解决方案】定位死锁对象，获取死锁SQL语句，自动死锁处理配置，预防优化方案
王大师企业官方博客
02-25 1209
学习教程（传送门）本人详解作者：王文峰，参加过 优快云 2020年度博客之星，《Java王大师王天师》公众号：JAVA开发王大师，专注于天道酬勤的 Java 开发问题中国国学、传统文化和代码爱好者的程序人生，期待你的关注和支持！本人外号：神秘小峯 山峯转载说明：务必注明来源（注明：作者：王文峰哦）【Oracle数据库死锁检查与解决方案】定位死锁对象，获取死锁SQL语句，自动死锁处理配置，预防优化方案学习教程（传送门）学习教程（传送门）往期文章学习教程（传送门）1、掌握入门到进阶知识(
什么情况下Java程序会产生死锁？如何定位、修复？
qq_14886109的博客
03-21 1181
死锁定位，死锁解决方案，jconsole ，jstack
java 死锁
mhbsoft的博客
12-10 170
DeadLockDemo.java class HoldLockThread implements Runnable { private String lockA; private String lockB; public HoldLockThread(String lockA, String lockB) { this.lockA = lockA; this.lockB = lockB; } @Override public
Java线程转储：快速定位死锁与阻塞
最新发布
HTTP404_CN的博客
06-14 524
Java获取线程转储的常用方法包括：1）命令行工具（jstack、jcmd或kill -3信号）；2）编程方式（ThreadMXBean API或Thread.getAllStackTraces()）；3）图形化工具（VisualVM/JConsole）。注意事项：输出需重定向到文件，高频获取可能短暂阻塞线程，推荐使用FastThread等工具分析。不同场景下可选择最合适的方法，如生产环境用jstack，自动化监控用ThreadMXBean。线程转储能有效诊断死锁、线程阻塞等问题。
JUC之死锁
weixin_44533129的博客
12-28 309
@[TOC] (死锁编码及定位分析) 1 概念 死锁是指两个或多个以上的进程在执行过程中，因争夺资源而造成一种互相等待的现象，若无外力干涉那他们都将无法推进下去。如果资源充足，进程的资源请求都能够得到满足，死锁出现的可能性就很低，否则就会因争夺有限的资源而陷入死锁。 2 产生死锁的原因 系统资源不足 进程运行推进的顺序不对 资源分配不当 死锁产生的四个必要条件: 互斥 解决方法：把互斥的共享资源封装成可同时访问 占有且等待 解决方法：进程请求资源时，要求它不占有任何其它资源，也就是它必须一次
阿里二面：如何定位&避免死锁？连着两个面试问到了！
俺叫赵小邪的博客
03-20 946
什么是死锁？死锁问题该如何定位？如何避免死锁？本文从这几个问题入手，详细的解释了死锁。
死锁定位分析
比利的博客
11-07 110
死锁定位分析
Oracle死锁定位及排查解决方案
张元礼-门道科技创始人|16年IT从业经验（抖音号：mtesting）
12-17 837
数据库的锁技术，是很多人头痛的部分，因为概念实在是抽象，如果没有一个深入浅出的道理去理解，光靠看各种搜索出来的文章，会各种云里雾里，下面我从个人的一些经验出发，和大家一起聊一聊锁。 锁：锁在SQL语句开始它们与数据的相互作用时获得，并在事务的整个过程中有效。 一个简单的理解：你要进家门，关门，进门拿东西等，必须先要获得开锁权和关锁权，否则没有办法完成你要做的事。 至于事务：你首先要具备...
Java中线程死锁问题的解决方法
shejizuopin的博客
05-07 846
锁的粒度控制避免嵌套锁，优先使用细粒度锁（如）替代。锁的持有时间尽量减少锁的持有时间，避免在锁内执行耗时操作（如I/O、网络请求）。锁的释放使用确保锁释放，或通过tryLock()的try-catch处理超时。数据库事务锁事务中按固定顺序获取表锁（如先products后orders），避免交叉锁竞争。监控与日志定期采集线程转储，结合监控平台（如Prometheus+Grafana）检测异常线程状态。Java线程死锁的核心在于打破循环等待条件。
db2死锁问题分析及解决方案
09-18
### DB2死锁问题分析及解决方案 #### 一、引言 在数据库管理与维护过程中，死锁问题是一个常见的挑战，特别是在使用IBM DB2这样的大型关系型数据库管理系统时。本文将详细探讨DB2中死锁问题的分析方法及有效的解决...
死锁如何定位，修复？及其预防？
qq_42762824的博客
11-16 398
模拟定位问题，就选取常见的jstack,可以使用jps或者系统的ps命令、任务管理器等工具，确定进程ID 其次，调用jstack获取线程栈： ${JAVA_HOME}\bin\jstack your_pid 仔细看，有一个线程掌握的一个锁恰好是下一个线程需要的锁 具体步骤是： 区分线程状态—>查看等待目标—>对比monitor等持有状态 所以,理解线程基本状态和并发相关元素是定位问题的关键，然后调用栈结构，可以找到问题 如果我们开发自己的管理工具，遇到死锁，可以用更加程序化的方式扫描服务进程
当项目有中多个线程，如何查找死锁？
热门推荐
ILOVEMYDEAR的博客
05-10 1万+
系列文章目录 提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录系列文章目录前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、pandas是什么？ 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。
7.4 死锁的定位方法
一点光辉的博客
07-11 380
7.4 实现动态顺序死锁
思考：Java如何定位死锁？
mf97532的博客
12-01 277
【代码】思考：Java如何定位死锁？
【并发编程】如何定位死锁
JJ_Notebook的博客
05-24 858
死锁：多个线程分别占用对方需要的同步资源不放弃，都在等待对方放弃。 死锁案例 以下案例演示了线程T1，T2出现死锁的情况： 线程T1在获得锁1的情况下还想获取线程T2拥有的锁2，而线程T2在拥有锁2的情况下还想获取线程1拥有的锁1。 public class DeadLockDemo { public static void main(String[] args) { Object obj1=new Object(); Object obj2=new Object()
java并发之死锁
weixin_40161962的博客
11-04 170
死锁编码以及定位分析 产生死锁的原因 死锁是指两个或两个以上的进程在执行过程中，因争夺资源而造成的一种相互等待的现象，如果无外力的干涉那它们都将无法推进下去，如果系统的资源充足，进程的资源请求都能够得到满足，死锁出现的可能性就很低，否则就会因争夺有限的资源而陷入死锁。 代码 public class DeadLockDemo { public static void main(String...
定位死锁位置(跨平台)
123456789
03-11 489
文章目录死锁产生如何定位 死锁产生 死锁是如此产生的，以下内容引用一个 Linux 上分析死锁的简单方法 死锁 (deallocks)： 是指两个或两个以上的进程（线程）在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。此时称系?统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程（线程）称为死锁进程（线程）。 由于资源占用是互斥的，当某个进程提出申请资...
死锁、活锁、饥饿&定位死锁&解决死锁
fengxiandada的博客
05-10 1038
文章目录1. 死锁2. 定位死锁2.1 jstack工具使用2.2 jconsole工具使用：3. 解决死锁3.1 哲学家就餐问题4. 活锁4.1 活锁原因4.2 活锁解决5. 饥饿6. 使用ReentrantLock解决死锁、活锁、饥饿6.1 解决哲学家就餐死锁问题 1. 死锁 死锁：一组互相竞争资源的线程因互相等待，导致“永久”阻塞的现象。 说白了就是：两个线程互相持有对方所需的资源，互不释放且互相等待 t1 线程获得A对象锁，接下来想获取B对象的锁 t2 线程获得B对象锁，接下来想获取A对象的锁
数据库死锁怎么解决
03-28
<think>嗯，用户问的是数据库死锁怎么解决。首先，我得先回忆一下数据库死锁的基本概念和常见原因。死锁是指两个或多个事务在执行过程中，因争夺资源而造成的一种互相等待的现象，如果没有外力介入，这些事务都无法继续执行。可能的原因包括事务之间的资源竞争、加锁顺序不一致，或者系统设计不合理导致循环等待。 接下来，我需要按照用户提供的系统级指令来组织回答。用户希望结构清晰，分步骤解决问题，所以可能需要分点说明。同时，要使用中文，并且数学表达式用$...$或$$...$$格式，不过在这个问题中可能不太涉及数学公式，但如果有涉及事务等待图或者算法的话，可能需要用LaTeX。 首先，可能需要介绍死锁的定义和原因，然后分步骤说明解决和预防的方法。解决死锁通常有检测与恢复、预防策略、避免策略，还有优化应用设计等。需要确保每个步骤都清晰，并且给出实际的例子或方法，比如设置锁超时、调整事务顺序等。 还要注意用户可能需要的是实际操作的解决方案，比如数据库配置参数，或者代码层面的调整。比如在MySQL中设置innodb_lock_wait_timeout，或者在代码中捕获死锁异常并重试事务。这些具体的技术细节需要准确，不能出错。 另外，用户可能对如何分析死锁原因感兴趣，比如查看数据库日志，使用SHOW ENGINE INNODB STATUS等命令。这部分可能需要详细说明，帮助用户诊断问题。 同时，要确保回答真实可靠，可能需要提到不同数据库系统的差异，比如Oracle、MySQL、PostgreSQL在处理死锁时的不同机制，但用户可能主要关注通用的方法，或者特定于某个数据库的解决方式。由于用户没有指定具体数据库，可能需要保持通用，但适当举例。 还要考虑预防措施，比如保持事务简短，按顺序访问资源，使用合适的索引减少锁冲突，这些都能有效减少死锁的发生概率。 最后，可能需要总结处理流程，比如先监控分析，再根据情况选择解决和预防策略。同时提醒用户死锁无法完全避免，但可以通过优化减少其发生。 在整理这些思路时，要确保结构清晰，分点明确，使用用户容易理解的语言，避免过于技术化的术语，但必要时给出术语并简单解释。同时，检查是否有遗漏的关键点，比如锁超时、死锁检测机制、事务重试等。</think>### 数据库死锁的解决与预防方法 #### 一、死锁的定义与原因 **死锁**是指两个或多个事务因争夺资源而陷入相互等待的状态，导致无法继续执行。常见原因包括： 1. **资源竞争**：事务同时请求相同资源（如行锁、表锁）。 2. **加锁顺序不一致**：事务以不同顺序获取锁，形成循环依赖。 3. **长事务与高并发**：长时间持有锁或高并发场景易引发死锁。 --- #### 二、解决方案：主动检测与恢复 1. **启用数据库死锁检测** - 多数数据库（如MySQL、PostgreSQL）内置死锁检测机制，发现死锁后自动终止“代价较小”的事务。 - **示例**：MySQL通过参数`innodb_deadlock_detect=ON`开启检测。 2. **设置锁超时时间** - 事务等待锁超过阈值后自动回滚，避免无限等待。 - **示例**：MySQL设置`innodb_lock_wait_timeout=50`（单位：秒）。 3. **手动干预** - 通过日志定位死锁事务，强制终止其一： ```sql -- PostgreSQL终止进程 SELECT pg_terminate_backend(pid); ``` --- #### 三、预防策略：减少死锁概率 1. **统一加锁顺序** - 所有事务按固定顺序访问资源（如按主键升序更新数据）。 - **示例**：对表A和表B的操作，始终先锁表A再锁表B。 2. **缩短事务长度** - 事务尽量简短，减少锁持有时间。避免在事务中执行耗时操作（如文件IO）。 3. **使用低隔离级别** - 降低隔离级别（如`READ COMMITTED`），减少锁竞争。但需权衡数据一致性。 4. **合理设计索引** - 优化查询索引，减少全表扫描导致的锁范围扩大。 5. **使用乐观锁** - 通过版本号（如`CAS`机制）替代悲观锁，适用于低冲突场景。 --- #### 四、应用层优化 1. **重试机制** - 捕获死锁异常（如MySQL的`1213`错误码），自动重试事务。 ```java // Java示例：重试3次 int retries = 3; while (retries-- > 0) { try { executeTransaction(); break; } catch (DeadlockException e) { rollback(); } } ``` 2. **批量提交** - 将多个操作合并为批量提交，减少锁竞争频率。 --- #### 五、诊断与分析工具 1. **查看数据库日志** - MySQL：`SHOW ENGINE INNODB STATUS`输出死锁详细信息。 - PostgreSQL：日志中记录`deadlock detected`及事务ID。 2. **监控工具** - 使用Prometheus+Grafana监控锁等待情况，或APM工具（如SkyWalking）分析慢事务。 --- #### 六、总结流程 1. **监控**：通过日志和工具定位死锁。 2. **解决**：终止事务或设置超时。 3. **预防**：优化事务设计、索引和并发控制。 4. **容错**：代码层添加重试逻辑。 > **关键原则**：死锁无法彻底避免，但可通过降低冲突概率和快速恢复减少影响。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值