JAVA线上死锁预警但业务未受影响的深度排查与修复

各位同学，今天我们来探讨一个比较棘手，但又经常被忽视的线上问题：JAVA线上死锁预警，但业务未受影响。这听起来有点矛盾，但实际情况中，由于死锁时间短、并发量低等原因，某些死锁确实可能不会直接导致业务中断，但它就像一颗定时炸弹，随时可能爆发，严重影响系统稳定性。

本次讲座将分为以下几个部分：

死锁原理回顾与危害性分析：明确死锁的概念、产生条件以及潜在的危害，强调即使“业务未受影响”也要重视死锁问题。
预警机制与工具介绍：介绍常用的死锁检测预警机制，以及分析死锁信息的工具。
问题排查与定位：深入探讨如何根据预警信息，结合线程Dump、日志等信息，定位到具体的死锁代码。
修复策略与代码实践：详细讲解常用的死锁修复策略，并结合实际代码案例进行演示。
预防措施与最佳实践：总结预防死锁的最佳实践，从代码设计、并发控制等方面入手，降低死锁发生的概率。

1. 死锁原理回顾与危害性分析

什么是死锁？

死锁是指两个或多个线程无限期地等待彼此释放资源，导致所有线程都无法继续执行的状态。这是一个操作系统层面的经典问题，在多线程编程中十分常见。

死锁产生的四个必要条件（缺一不可）：

条件	描述
互斥条件	线程对所分配的资源进行排他性控制，即同一时刻只能有一个线程占有该资源。
占有且等待条件	线程已经占有至少一个资源，但又提出新的资源请求，而该资源已被其他线程占有，此时线程阻塞，在等待新资源的同时，不释放已经占有的资源。
不可剥夺条件	线程已经获得的资源，在未使用完毕之前，不能被其他线程强行剥夺，只能由占有它的线程主动释放。
循环等待条件	存在一个线程等待资源的环形链，例如，线程A等待线程B占有的资源，线程B等待线程C占有的资源，线程C又等待线程A占有的资源，形成一个环路。

死锁的危害性：

虽然本次讨论的主题是"业务未受影响"的死锁，但这并不意味着我们可以忽视它。死锁可能带来的危害包括：

系统性能下降： 即使业务未直接中断，但死锁线程会占用CPU资源，降低系统的整体性能，增加响应时间。
资源浪费： 死锁线程占用的资源无法被其他线程使用，造成资源浪费。
潜在的业务中断风险： 随着并发量增加，死锁发生的概率和持续时间也会增加，最终可能导致业务中断。
维护成本增加： 排查和解决死锁问题需要耗费大量时间和精力。
雪崩效应： 多个服务互相依赖，如果一个服务因为死锁发生故障，可能会引发连锁反应，导致整个系统崩溃。

关键点： 即使当前业务未受影响，死锁的存在也会增加系统的风险，必须尽快解决。

2. 预警机制与工具介绍

常用的死锁检测预警机制：

JVM 自带的死锁检测机制： 通过 ThreadMXBean 接口可以检测到死锁。可以通过编程方式定期调用 ThreadMXBean.findDeadlockedThreads() 方法来检测死锁，并发送预警。
监控系统（例如：Prometheus + Grafana） + JMX Exporter： 通过 JMX Exporter 将 JVM 的指标暴露给 Prometheus，然后在 Grafana 中配置监控面板，当死锁线程数超过阈值时，触发告警。
APM 工具（例如：SkyWalking, Pinpoint, CAT）： APM 工具可以自动检测到死锁，并提供详细的线程Dump信息，帮助定位问题。

死锁信息分析工具：

jstack： JDK 自带的命令行工具，可以生成线程Dump文件，用于分析线程状态和锁的持有情况。
- jstack <pid> 生成指定进程ID的线程Dump文件。
jconsole： JDK 自带的可视化监控工具，可以查看线程信息、内存信息等，并进行简单的线程Dump分析。
VisualVM： JDK 自带的强大的可视化监控工具，可以进行线程Dump分析、内存分析、CPU Profiling 等。
线程Dump分析器： 一些在线或离线的线程Dump分析器，可以自动分析线程Dump文件，并生成报告，帮助定位死锁问题。例如：fastThread, TDA。

代码示例（使用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[] deadlockedThreadIds = threadMXBean.findDeadlockedThreads();

        if (deadlockedThreadIds != null && deadlockedThreadIds.length > 0) {
            System.err.println("发现死锁！");
            ThreadInfo[] threadInfos = threadMXBean.getThreadInfo(deadlockedThreadIds, true, true);

            for (ThreadInfo threadInfo : threadInfos) {
                System.err.println(threadInfo.toString());
            }

            // 发送预警信息（例如：通过邮件、短信等）
            sendAlert("发现死锁！详情请查看线程Dump信息。");
        }
    }

    private static void sendAlert(String message) {
        // 实现发送预警信息的逻辑
        System.err.println("发送预警信息：" + message);
    }

    public static void main(String[] args) throws InterruptedException {
        // 模拟死锁场景
        Object lock1 = new Object();
        Object lock2 = new Object();

        Thread thread1 = new Thread(() -> {
            synchronized (lock1) {
                System.out.println("线程1 获取 lock1");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("线程1 尝试获取 lock2");
                synchronized (lock2) {
                    System.out.println("线程1 获取 lock2");
                }
            }
        });

        Thread thread2 = new Thread(() -> {
            synchronized (lock2) {
                System.out.println("线程2 获取 lock2");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("线程2 尝试获取 lock1");
                synchronized (lock1) {
                    System.out.println("线程2 获取 lock1");
                }
            }
        });

        thread1.start();
        thread2.start();

        Thread.sleep(500); // 等待一段时间，让死锁发生

        detectDeadlock(); // 检测死锁
    }
}

关键点： 选择合适的预警机制和工具，能够及时发现死锁，并提供有效的分析信息。

3. 问题排查与定位

排查思路：

查看预警信息： 分析预警信息，例如：死锁线程的ID、线程名称、堆栈信息等。
生成线程Dump文件： 使用 jstack 命令生成线程Dump文件。
分析线程Dump文件： 使用线程Dump分析工具或手动分析，查找死锁线程，以及它们正在等待的锁。
定位代码： 根据线程Dump信息，定位到具体的代码行，分析代码逻辑，找出死锁的原因。
复现问题： 尝试在测试环境中复现死锁问题，以便更好地进行调试和修复。

线程Dump文件分析示例：

假设我们有一个线程Dump文件，其中包含以下信息：

"Thread-1" #15 prio=5 os_prio=0 tid=0x00007f9c98123000 nid=0x3b waiting for monitor entry [0x00007f9c8c23f000]
   java.lang.Thread.State: BLOCKED (on object monitor)
        at com.example.DeadlockExample.lambda$0(DeadlockExample.java:25)
        - waiting to lock <0x000000076b77a330> (a java.lang.Object)
        - locked <0x000000076b77a320> (a java.lang.Object)
        at com.example.DeadlockExample$$Lambda$1/1482091338.run(Unknown Source)
        at java.lang.Thread.run(Thread.java:748)

"Thread-2" #16 prio=5 os_prio=0 tid=0x00007f9c98124000 nid=0x3c waiting for monitor entry [0x00007f9c8c33f000]
   java.lang.Thread.State: BLOCKED (on object monitor)
        at com.example.DeadlockExample.lambda$1(DeadlockExample.java:39)
        - waiting to lock <0x000000076b77a320> (a java.lang.Object)
        - locked <0x000000076b77a330> (a java.lang.Object)
        at com.example.DeadlockExample$$Lambda$2/1482091339.run(Unknown Source)
        at java.lang.Thread.run(Thread.java:748)

分析结果：

"Thread-1" 线程正在等待锁 <0x000000076b77a330>，但已经持有锁 <0x000000076b77a320>。
"Thread-2" 线程正在等待锁 <0x000000076b77a320>，但已经持有锁 <0x000000076b77a330>。
代码行 com.example.DeadlockExample.java:25 和 com.example.DeadlockExample.java:39 可能是死锁的关键代码。

定位代码：

根据线程Dump信息，可以定位到以下代码：

// DeadlockExample.java
public class DeadlockExample {

    public static void main(String[] args) throws InterruptedException {
        Object lock1 = new Object();
        Object lock2 = new Object();

        Thread thread1 = new Thread(() -> {
            synchronized (lock1) { // 第25行
                System.out.println("线程1 获取 lock1");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (lock2) {
                    System.out.println("线程1 获取 lock2");
                }
            }
        });

        Thread thread2 = new Thread(() -> {
            synchronized (lock2) { // 第39行
                System.out.println("线程2 获取 lock2");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (lock1) {
                    System.out.println("线程2 获取 lock1");
                }
            }
        });

        thread1.start();
        thread2.start();

        Thread.sleep(500);
    }
}

关键点： 熟练掌握线程Dump分析，能够快速定位到死锁代码。

4. 修复策略与代码实践

常用的死锁修复策略：

避免多个锁： 尽量减少同时持有多个锁的情况。如果必须持有多个锁，确保以相同的顺序获取锁，避免循环等待。
使用锁的超时机制： 使用 tryLock(long timeout, TimeUnit unit) 方法，设置锁的超时时间。如果在指定时间内无法获取锁，则释放已经持有的锁，避免长时间等待。
使用可中断锁： 使用 lockInterruptibly() 方法获取锁，允许线程在等待锁的过程中被中断。
避免在持有锁的情况下执行耗时操作： 避免在持有锁的情况下执行IO操作、网络请求等耗时操作，减少锁的持有时间。
使用并发容器： 使用 ConcurrentHashMap, ConcurrentLinkedQueue 等并发容器，减少对锁的依赖。
使用原子类： 使用 AtomicInteger, AtomicLong 等原子类，进行原子操作，避免使用锁。
重入锁： 使用 ReentrantLock 代替 synchronized，ReentrantLock 提供了更多的灵活性，例如可重入、公平锁、条件变量等。

代码示例（使用锁的超时机制修复死锁）：

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class DeadlockFixedExample {

    private static final Lock lock1 = new ReentrantLock();
    private static final Lock lock2 = new ReentrantLock();

    public static void main(String[] args) throws InterruptedException {

        Thread thread1 = new Thread(() -> {
            try {
                if (lock1.tryLock(1, TimeUnit.SECONDS)) {
                    try {
                        System.out.println("线程1 获取 lock1");
                        Thread.sleep(100);
                        if (lock2.tryLock(1, TimeUnit.SECONDS)) {
                            try {
                                System.out.println("线程1 获取 lock2");
                            } finally {
                                lock2.unlock();
                            }
                        } else {
                            System.out.println("线程1 获取 lock2 超时，释放 lock1");
                        }
                    } finally {
                        lock1.unlock();
                    }
                } else {
                    System.out.println("线程1 获取 lock1 超时");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        Thread thread2 = new Thread(() -> {
            try {
                if (lock2.tryLock(1, TimeUnit.SECONDS)) {
                    try {
                        System.out.println("线程2 获取 lock2");
                        Thread.sleep(100);
                        if (lock1.tryLock(1, TimeUnit.SECONDS)) {
                            try {
                                System.out.println("线程2 获取 lock1");
                            } finally {
                                lock1.unlock();
                            }
                        } else {
                            System.out.println("线程2 获取 lock1 超时，释放 lock2");
                        }
                    } finally {
                        lock2.unlock();
                    }
                } else {
                    System.out.println("线程2 获取 lock2 超时");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        thread1.start();
        thread2.start();

        Thread.sleep(500);
    }
}

代码示例（使用相同的顺序获取锁）：

public class DeadlockFixedExample2 {

    private static final Object lock1 = new Object();
    private static final Object lock2 = new Object();

    public static void main(String[] args) throws InterruptedException {

        Thread thread1 = new Thread(() -> {
            synchronized (lock1) {
                System.out.println("线程1 获取 lock1");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (lock2) {
                    System.out.println("线程1 获取 lock2");
                }
            }
        });

        Thread thread2 = new Thread(() -> {
            synchronized (lock1) { // 关键：线程2 也先获取 lock1
                System.out.println("线程2 获取 lock1");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (lock2) {
                    System.out.println("线程2 获取 lock2");
                }
            }
        });

        thread1.start();
        thread2.start();

        Thread.sleep(500);
    }
}

关键点： 选择合适的修复策略，并结合实际代码进行实践，确保死锁问题得到彻底解决。

5. 预防措施与最佳实践

预防死锁的最佳实践：

代码审查： 在代码提交之前，进行代码审查，检查是否存在潜在的死锁风险。
单元测试： 编写单元测试，模拟并发场景，测试代码是否存在死锁问题。
压力测试： 在生产环境中进行压力测试，模拟高并发场景，检测系统是否存在死锁问题。
使用静态代码分析工具： 使用 FindBugs, PMD 等静态代码分析工具，检测代码中潜在的死锁风险。
避免使用过多的锁： 尽量减少对锁的依赖，可以使用并发容器、原子类等方式来避免使用锁。
设计良好的并发模型： 选择合适的并发模型，例如：Actor 模型、CSP 模型等，降低死锁发生的概率。
监控和告警： 建立完善的监控和告警机制，及时发现死锁问题。
培训和学习： 加强对并发编程的学习和培训，提高开发人员的并发编程能力。

最佳实践表格：

方面	最佳实践
代码设计	单一职责原则：尽量保持每个方法只做一件事情，减少锁的竞争。避免过长的同步块：尽量缩小同步块的范围，减少锁的持有时间。 * 使用不可变对象：尽量使用不可变对象，避免多线程并发修改导致的问题。
并发控制	优先使用并发容器和原子类：尽量使用 `ConcurrentHashMap`, `AtomicInteger` 等并发容器和原子类，减少对锁的依赖。使用显式锁（`ReentrantLock`）：使用 `ReentrantLock` 代替 `synchronized`，`ReentrantLock` 提供了更多的灵活性，例如可重入、公平锁、条件变量等。避免循环等待：确保以相同的顺序获取锁，避免循环等待。设置锁的超时时间：使用 `tryLock(long timeout, TimeUnit unit)` 方法，设置锁的超时时间。
测试和监控	编写并发单元测试：编写单元测试，模拟并发场景，测试代码是否存在死锁问题。进行压力测试：在生产环境中进行压力测试，模拟高并发场景，检测系统是否存在死锁问题。 * 建立监控和告警机制：建立完善的监控和告警机制，及时发现死锁问题。

关键点： 预防胜于治疗，从代码设计、并发控制等方面入手，降低死锁发生的概率。

总结一下：

本次讲座我们深入探讨了JAVA线上死锁预警但业务未受影响的问题，从死锁原理、预警机制、问题排查、修复策略到预防措施，进行了全面的讲解。希望大家能够重视死锁问题，掌握排查和解决死锁的方法，并将其应用到实际工作中，提高系统的稳定性和可靠性。