Java程序死锁了怎么排查定位并解决？

理解Java死锁的本质

Java死锁是指两个或多个线程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法继续执行，从操作系统层面看，死锁的产生必须满足四个必要条件：互斥条件、占有并等待条件、不可剥夺条件以及循环等待条件，在Java中，最常见的死锁场景发生在多个线程同时锁定多个对象，并以不同顺序获取锁时，线程A先锁定对象obj1再尝试锁定obj2，而线程B先锁定obj2再尝试锁定obj1，如果双方都持有所需的第一个锁且不释放，就会形成循环等待，导致死锁。

死锁的常见场景与代码示例

多锁顺序不一致导致的死锁

public class DeadlockExample {  
    private static final Object lock1 = new Object();  
    private static final Object lock2 = new Object();  
    public static void main(String[] args) {  
        Thread thread1 = new Thread(() -> {  
            synchronized (lock1) {  
                System.out.println("Thread1 holds lock1");  
                try { Thread.sleep(100); } catch (InterruptedException e) {}  
                synchronized (lock2) {  
                    System.out.println("Thread1 acquired lock2");  
                }  
            }  
        });  
        Thread thread2 = new Thread(() -> {  
            synchronized (lock2) {  
                System.out.println("Thread2 holds lock2");  
                try { Thread.sleep(100); } catch (InterruptedException e) {}  
                synchronized (lock1) {  
                    System.out.println("Thread2 acquired lock1");  
                }  
            }  
        });  
        thread1.start();  
        thread2.start();  
    }  
}  

上述代码中，thread1和thread2分别以不同顺序获取lock1和lock2，当双方都持有第一个锁并等待第二个锁时，死锁发生。

数据库连接池与线程池中的死锁

在高并发场景下，若数据库连接池中的连接数量不足，且线程在获取连接时未设置超时时间，也可能导致死锁，多个线程同时申请连接，部分线程已获取连接但等待其他资源，而剩余连接被其他线程占用，形成资源竞争闭环。

死锁的检测与定位工具

使用JDK工具：jstack

jstack是JDK自带的线程堆栈分析工具，可通过以下步骤检测死锁：

1. 执行jps查看Java进程ID；
2. 执行jstack -l <进程ID>生成线程快照，在输出中查找”Found one Java-level deadlock”字样，定位死锁线程及持有的锁。

使用VisualVM或JConsole

VisualVM和JConsole是JDK提供的可视化监控工具，可实时查看线程状态，在”线程”标签页下，通过”检测死锁”按钮快速定位死锁线程，并查看线程堆栈和锁持有情况。

日志与代码定位

在代码中关键同步块前后添加日志，记录线程获取锁的顺序和耗时。

synchronized (lock1) {  
    log.info("Thread {} acquired lock1", Thread.currentThread().getName());  
    // 业务逻辑  
}  

通过分析日志时序，可发现锁获取的异常等待情况。

死锁的预防策略

固定锁获取顺序

避免多个线程以不同顺序获取多个锁，可通过统一锁顺序规则预防死锁，为所有锁分配全局ID，线程按ID升序获取锁：

public void transfer(Account from, Account to, int amount) {  
    int lock1 = Math.min(from.hashCode(), to.hashCode());  
    int lock2 = Math.max(from.hashCode(), to.hashCode());  
    synchronized (getLock(lock1)) {  
        synchronized (getLock(lock2)) {  
            // 转账逻辑  
        }  
    }  
}  

超时机制

使用Lock接口的tryLock(long time, TimeUnit unit)方法，设置锁获取超时时间，避免无限等待：

Lock lock1 = new ReentrantLock();  
Lock lock2 = new ReentrantLock();  
if (lock1.tryLock(1, TimeUnit.SECONDS)) {  
    try {  
        if (lock2.tryLock(1, TimeUnit.SECONDS)) {  
            try {  
                // 业务逻辑  
            } finally {  
                lock2.unlock();  
            }  
        }  
    } finally {  
        lock1.unlock();  
    }  
}  

减少锁的持有范围

避免在同步块中执行耗时操作（如I/O、网络请求），尽量缩小锁的粒度，降低锁竞争概率。

synchronized (lock) {  
    // 仅保护共享数据的读写  
    int count = sharedData.getCount();  
}  
// 耗时操作放在同步块外  
processData(count);  

死锁的恢复与处理方案

线程终止与重启

在检测到死锁后，可通过终止死锁线程并重新创建线程实例恢复服务，但需确保线程状态可重置，避免资源泄露。

资源剥夺与重启

对于关键业务系统，可设计资源监控模块，定期检测死锁并触发应用重启，结合Kubernetes等容器编排工具，可实现自动重启与流量切换，保障服务可用性。

使用分布式锁框架

在分布式系统中，可基于Redis或Zookeeper实现分布式锁，避免多节点间的锁竞争，使用Redis的SETNX命令实现锁的原子性获取：

String lockKey = "resource_lock";  
String lockValue = UUID.randomUUID().toString();  
// 尝试获取锁，超时时间10秒  
Boolean locked = redisTemplate.opsForValue().setIfAbsent(lockKey, lockValue, 10, TimeUnit.SECONDS);  
if (locked) {  
    try {  
        // 业务逻辑  
    } finally {  
        // 释放锁（需保证原子性）  
        String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";  
        redisTemplate.execute(new DefaultRedisScript<>(script, Long.class), Collections.singletonList(lockKey), lockValue);  
    }  
}  

总结与最佳实践

处理Java死锁的核心在于”预防为主，检测为辅，恢复兜底”，在实际开发中，应遵循以下原则：

1. 简化锁逻辑：避免嵌套锁，尽量使用java.util.concurrent包下的工具类（如ReentrantLock、CountDownLatch）；
2. 代码评审：在团队中建立锁使用规范，对多线程代码进行重点评审；
3. 监控告警：集成APM工具（如Arthas、SkyWalking），实时监控线程状态与锁竞争情况；
4. 测试覆盖：通过压力测试和混沌工程模拟高并发场景，提前暴露死锁风险。

通过以上策略的综合应用，可有效降低Java死锁的发生概率,提升系统的稳定性和可靠性。