Java线程死锁案例如何检测

本文目录导读：

1. 死锁案例演示
2. 检测方法
3. 死锁检测输出解读
4. 预防和解决建议
5. 检测技巧总结

我来给你详细介绍Java线程死锁的检测方法,包括代码示例和实操技巧。

死锁案例演示

先创建一个典型的死锁场景：

public class DeadlockExample {
    private static final Object resource1 = new Object();
    private static final Object resource2 = new Object();
    public static void main(String[] args) {
        // 线程1：先获取resource1，再获取resource2
        Thread thread1 = new Thread(() -> {
            synchronized (resource1) {
                System.out.println("线程1：获取到资源1");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (resource2) {
                    System.out.println("线程1：获取到资源2");
                }
            }
        });
        // 线程2：先获取resource2，再获取resource1
        Thread thread2 = new Thread(() -> {
            synchronized (resource2) {
                System.out.println("线程2：获取到资源2");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (resource1) {
                    System.out.println("线程2：获取到资源1");
                }
            }
        });
        thread1.start();
        thread2.start();
    }
}

检测方法

使用jstack命令（推荐）

# 1. 先找到Java进程ID
jps -l
# 2. 使用jstack分析线程堆栈
jstack -l <进程ID>

输出中会明确显示死锁信息：

Found one Java-level deadlock:
=============================
"Thread-1":
  waiting to lock monitor 0x000000001d3d4e58 (object 0x000000076b5c6a90, a java.lang.Object),
  which is held by "Thread-0"
"Thread-0":
  waiting to lock monitor 0x000000001d3d4f08 (object 0x000000076b5c6aa0, a java.lang.Object),
  which is held by "Thread-1"
Java stack information for the threads listed above:
===================================================
...

使用jconsole可视化工具

1. 启动jconsole：

   jconsole

2. 选择对应的Java进程

3. 点击"检测死锁"按钮

4. 可以直观看到死锁的线程和等待的资源

使用ThreadMXBean编程检测

import java.lang.management.ManagementFactory;
import java.lang.management.ThreadInfo;
import java.lang.management.ThreadMXBean;
public class DeadlockDetector {
    public static void detectDeadlock() {
        ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
        // 检测死锁
        long[] deadlockedThreads = threadMXBean.findDeadlockedThreads();
        if (deadlockedThreads != null && deadlockedThreads.length > 0) {
            System.out.println("检测到死锁！");
            ThreadInfo[] threadInfos = threadMXBean.getThreadInfo(deadlockedThreads);
            for (ThreadInfo threadInfo : threadInfos) {
                System.out.println("线程ID: " + threadInfo.getThreadId());
                System.out.println("线程名称: " + threadInfo.getThreadName());
                System.out.println("线程状态: " + threadInfo.getThreadState());
                System.out.println("等待的锁: " + threadInfo.getLockName());
                System.out.println("拥有锁的线程: " + threadInfo.getLockOwnerName());
                System.out.println("---");
            }
        } else {
            System.out.println("未检测到死锁");
        }
    }
    public static void main(String[] args) {
        // 启动一个定时检测线程
        Thread detectorThread = new Thread(() -> {
            while (true) {
                detectDeadlock();
                try {
                    Thread.sleep(5000); // 每5秒检测一次
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        detectorThread.setDaemon(true);
        detectorThread.start();
        // 启动死锁示例
        DeadlockExample.main(args);
    }
}

使用VisualVM

1. 启动VisualVM：

   jvisualvm

2. 选择进程

3. 点击"线程"标签

4. 查看"检测死锁"状态

死锁检测输出解读

当检测到死锁时,关键信息包括：

Found 1 deadlock.    // 发现1个死锁
Thread-0:           // 线程名称
  waiting to lock <0x000000076b5c6a90> (a java.lang.Object)  // 等待的锁
  which is held by Thread-1                                  // 被谁持有
Thread-1:
  waiting to lock <0x000000076b5c6aa0> (a java.lang.Object)
  which is held by Thread-0

预防和解决建议

// 预防死锁：固定锁获取顺序
public class DeadlockPrevention {
    private static final Object resource1 = new Object();
    private static final Object resource2 = new Object();
    public static void safeMethod() {
        // 按照固定的顺序获取锁
        synchronized (resource1) {
            synchronized (resource2) {
                // 业务逻辑
            }
        }
    }
    // 或者使用tryLock设置超时
    public static void tryLockMethod() {
        Lock lock1 = new ReentrantLock();
        Lock lock2 = new ReentrantLock();
        while (true) {
            if (lock1.tryLock()) {
                try {
                    if (lock2.tryLock()) {
                        try {
                            // 业务逻辑
                            break;
                        } finally {
                            lock2.unlock();
                        }
                    }
                } finally {
                    lock1.unlock();
                }
            }
            // 等待一段时间后重试
            try {
                Thread.sleep(new Random().nextInt(100));
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                break;
            }
        }
    }
}

检测技巧总结

1. 定期检测：在生产环境部署死锁检测脚本
2. 日志分析：记录线程dump日志，定期分析
3. 监控告警：结合APM工具设置死锁告警
4. 代码审查：审查锁的使用顺序是否一致
5. 压力测试：在高并发场景下测试是否存在死锁

使用这些方法,你可以快速定位和解决Java线程死锁问题。