JAVA多线程死锁排查：JStack线程快照分析与代码修复套路

大家好，今天我们来聊聊Java多线程编程中一个令人头疼的问题：死锁。死锁就像交通堵塞，多个线程互相持有对方需要的资源，导致所有线程都无法继续执行，程序卡死。掌握死锁的排查和修复方法对于编写健壮的多线程应用至关重要。

本次讲座将主要围绕以下几个方面展开：

死锁的概念与产生原因： 深入理解死锁的定义和产生条件。
JStack工具的使用： 学习如何利用JStack生成线程快照。
线程快照分析： 解读JStack生成的线程快照，定位死锁线程。
死锁代码修复套路： 介绍几种常见的死锁修复策略，并结合代码示例进行讲解。

1. 死锁的概念与产生原因

什么是死锁？

死锁是指两个或多个线程无限期地阻塞，等待彼此释放资源，而这些线程又都持有对方需要的资源。结果是，这些线程都不能继续运行，程序陷入停顿状态。

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

互斥条件（Mutual Exclusion）： 资源只能同时被一个线程占用。
请求与保持条件（Hold and Wait）： 线程已经保持了至少一个资源，但又提出了新的资源请求，而该资源已被其他线程占用。
不可剥夺条件（No Preemption）： 线程已获得的资源，在未使用完之前，不能被其他线程强行剥夺。
循环等待条件（Circular Wait）： 存在一个线程等待资源的循环链，例如线程A等待线程B占用的资源，线程B等待线程C占用的资源，线程C等待线程A占用的资源。

只有当这四个条件同时满足时，才会发生死锁。

2. JStack工具的使用

JStack是JDK自带的线程堆栈分析工具，它可以生成指定Java进程的线程快照，用于诊断线程死锁、长时间等待等问题。

如何使用JStack？

获取Java进程ID (PID)：

可以使用jps命令或者操作系统的任务管理器来获取Java进程的PID。
```
jps
```
这个命令会列出当前运行的所有Java进程及其对应的PID。
生成线程快照：

使用以下命令生成线程快照：
```
jstack <PID> > thread_dump.txt
```
其中<PID>是Java进程的PID，thread_dump.txt是保存线程快照的文件名。也可以直接将信息打印到控制台，不指定输出文件即可。

JStack 命令的常见选项：

选项	描述
-l	输出更详细的线程信息，例如锁的拥有者、等待队列等。
-m	输出本地方法栈帧的信息，对于排查 native 代码引起的死锁可能有用。
-F	当 jstack 无法正常响应时，强制生成线程快照（可能不完整）。
-h or -help	显示帮助信息。

3. 线程快照分析

JStack生成的线程快照是一个文本文件，包含了Java虚拟机中所有线程的详细信息，包括线程ID、线程状态、线程堆栈等。我们需要分析这些信息来定位死锁线程。

线程快照的关键信息：

线程名称 (Name)： 描述线程的作用，方便识别。
线程ID (nid)： 线程的唯一标识符，以十六进制表示。
线程状态 (State)： 线程的当前状态，例如RUNNABLE、BLOCKED、WAITING、TIMED_WAITING等。
线程堆栈 (Stack trace)： 线程当前执行的代码路径，显示了方法调用的层次关系。
锁信息： 线程持有的锁 (locked) 和等待的锁 (waiting on)。

分析死锁线程的步骤：

查找死锁信息： JStack通常会在线程快照的末尾自动检测并报告死锁信息。查找类似 "Deadlock detected!" 或者 "Found one Java-level deadlock:" 的提示。
定位死锁线程： 根据死锁信息，找到参与死锁的线程名称和ID。
分析线程堆栈： 仔细分析死锁线程的堆栈信息，找到线程阻塞的位置，确定线程正在等待哪个锁。
确定锁的持有者： 找到持有线程正在等待的锁的线程，分析其堆栈信息，确定该线程为什么没有释放锁。
分析资源竞争： 综合分析所有参与死锁的线程，确定它们之间存在怎样的资源竞争关系，导致了死锁。

一个死锁线程快照示例 (简化版)：

"Thread-1" #10 prio=5 os_prio=0 tid=0x00007f8c08123400 nid=0xa waiting for monitor entry [0x00007f8c07b22000]
   java.lang.Thread.State: BLOCKED (on object monitor)
    at com.example.DeadlockExample.methodA(DeadlockExample.java:20)
    - waiting to lock <0x000000076b225030> (a java.lang.String)
    at com.example.DeadlockExample.run(DeadlockExample.java:35)
    at java.lang.Thread.run(Thread.java:748)

"Thread-2" #11 prio=5 os_prio=0 tid=0x00007f8c08124800 nid=0xb waiting for monitor entry [0x00007f8c07c23000]
   java.lang.Thread.State: BLOCKED (on object monitor)
    at com.example.DeadlockExample.methodB(DeadlockExample.java:25)
    - waiting to lock <0x000000076b225040> (a java.lang.String)
    at com.example.DeadlockExample.run(DeadlockExample.java:40)
    at java.lang.Thread.run(Thread.java:748)

Found one Java-level deadlock:
=============================
"Thread-2":
  waiting to lock monitor 0x00007f8c07c23000 (object 0x000000076b225040, a java.lang.String),
  which is held by "Thread-1"
"Thread-1":
  waiting to lock monitor 0x00007f8c07b22000 (object 0x000000076b225030, a java.lang.String),
  which is held by "Thread-2"

在这个例子中，JStack检测到了一个死锁。Thread-1 正在等待 Thread-2 持有的锁 0x000000076b225040，而 Thread-2 正在等待 Thread-1 持有的锁 0x000000076b225030。通过堆栈信息，我们可以定位到死锁发生的具体代码位置，分别是DeadlockExample.java的第20行和第25行。

4. 死锁代码修复套路

找到死锁的原因之后，就可以采取相应的措施来修复死锁。常见的修复策略包括：

避免多个锁： 尽量减少线程需要同时持有的锁的数量。如果可能，将多个操作合并为一个原子操作，只需要一个锁保护。

示例：

死锁代码：

public class Account {
    private int balance;
    private final Object lock1 = new Object();
    private final Object lock2 = new Object();

    public void transfer(Account target, int amount) {
        synchronized (lock1) {
            synchronized (target.lock1) { //潜在死锁点
                this.balance -= amount;
                target.balance += amount;
            }
        }
    }
}

修复后的代码： (假设只对自身账户进行操作)

public class Account {
    private int balance;
    private final Object lock = new Object(); //使用一个锁

    public void transfer(int amount) {
        synchronized (lock) {
            this.balance += amount;
        }
    }
}

锁的顺序一致： 如果多个线程需要获取多个锁，确保所有线程都按照相同的顺序获取锁。这样可以避免循环等待的发生。

示例：

死锁代码：

public class DeadlockExample {
    private final Object lockA = new Object();
    private final Object lockB = new Object();

    public void methodA() {
        synchronized (lockA) {
            System.out.println("Thread " + Thread.currentThread().getName() + " acquired lockA");
            try { Thread.sleep(100); } catch (InterruptedException e) {}
            synchronized (lockB) {
                System.out.println("Thread " + Thread.currentThread().getName() + " acquired lockB");
            }
        }
    }

    public void methodB() {
        synchronized (lockB) {
            System.out.println("Thread " + Thread.currentThread().getName() + " acquired lockB");
            try { Thread.sleep(100); } catch (InterruptedException e) {}
            synchronized (lockA) { //锁的顺序与methodA相反，导致死锁
                System.out.println("Thread " + Thread.currentThread().getName() + " acquired lockA");
            }
        }
    }

    public static void main(String[] args) {
        DeadlockExample example = new DeadlockExample();
        new Thread(() -> example.methodA(), "Thread-1").start();
        new Thread(() -> example.methodB(), "Thread-2").start();
    }
}

修复后的代码： (锁的顺序保持一致)

public class DeadlockExample {
    private final Object lockA = new Object();
    private final Object lockB = new Object();

    public void methodA() {
        synchronized (lockA) {
            System.out.println("Thread " + Thread.currentThread().getName() + " acquired lockA");
            try { Thread.sleep(100); } catch (InterruptedException e) {}
            synchronized (lockB) {
                System.out.println("Thread " + Thread.currentThread().getName() + " acquired lockB");
            }
        }
    }

    public void methodB() {
        synchronized (lockA) { //锁的顺序与methodA相同
            System.out.println("Thread " + Thread.currentThread().getName() + " acquired lockA");
            try { Thread.sleep(100); } catch (InterruptedException e) {}
            synchronized (lockB) {
                System.out.println("Thread " + Thread.currentThread().getName() + " acquired lockB");
            }
        }
    }

    public static void main(String[] args) {
        DeadlockExample example = new DeadlockExample();
        new Thread(() -> example.methodA(), "Thread-1").start();
        new Thread(() -> example.methodB(), "Thread-2").start();
    }
}

使用定时锁： 使用tryLock()方法尝试获取锁，并设置超时时间。如果在指定时间内无法获取锁，则释放已持有的锁，避免长时间等待。

示例：

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

public class TimedLockExample {
    private final Lock lockA = new ReentrantLock();
    private final Lock lockB = new ReentrantLock();

    public void methodA() {
        try {
            if (lockA.tryLock(1, TimeUnit.SECONDS)) {
                try {
                    System.out.println("Thread " + Thread.currentThread().getName() + " acquired lockA");
                    Thread.sleep(100);
                    if (lockB.tryLock(1, TimeUnit.SECONDS)) {
                        try {
                            System.out.println("Thread " + Thread.currentThread().getName() + " acquired lockB");
                        } finally {
                            lockB.unlock();
                        }
                    } else {
                        System.out.println("Thread " + Thread.currentThread().getName() + " failed to acquire lockB, releasing lockA");
                    }
                } finally {
                    lockA.unlock();
                }
            } else {
                System.out.println("Thread " + Thread.currentThread().getName() + " failed to acquire lockA");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public void methodB() {
        try {
            if (lockB.tryLock(1, TimeUnit.SECONDS)) {
                try {
                    System.out.println("Thread " + Thread.currentThread().getName() + " acquired lockB");
                    Thread.sleep(100);
                    if (lockA.tryLock(1, TimeUnit.SECONDS)) {
                        try {
                            System.out.println("Thread " + Thread.currentThread().getName() + " acquired lockA");
                        } finally {
                            lockA.unlock();
                        }
                    } else {
                        System.out.println("Thread " + Thread.currentThread().getName() + " failed to acquire lockA, releasing lockB");
                    }
                } finally {
                    lockB.unlock();
                }
            } else {
                System.out.println("Thread " + Thread.currentThread().getName() + " failed to acquire lockB");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        TimedLockExample example = new TimedLockExample();
        new Thread(() -> example.methodA(), "Thread-1").start();
        new Thread(() -> example.methodB(), "Thread-2").start();
    }
}

资源分配策略： 设计合理的资源分配策略，避免线程长时间占用资源。例如，可以限制线程持有资源的时间，或者使用资源池来管理资源。
死锁检测与恢复： 在某些情况下，可以通过编写代码来检测死锁的发生，并尝试恢复。例如，可以定期检查线程的等待状态，如果发现死锁，则强制中断某些线程，释放资源。（这种方法比较复杂，通常不建议使用）

使用并发容器： Java提供了一些线程安全的并发容器，例如ConcurrentHashMap、BlockingQueue等。使用这些容器可以减少对锁的依赖，降低死锁的风险。

示例：

使用普通HashMap (需要手动加锁):

import java.util.HashMap;
import java.util.Map;

public class HashMapExample {
    private final Map<String, Integer> map = new HashMap<>();

    public synchronized void put(String key, Integer value) {
        map.put(key, value);
    }

    public synchronized Integer get(String key) {
        return map.get(key);
    }
}

使用ConcurrentHashMap (线程安全，无需手动加锁):

import java.util.concurrent.ConcurrentHashMap;
import java.util.Map;

public class ConcurrentHashMapExample {
    private final Map<String, Integer> map = new ConcurrentHashMap<>();

    public void put(String key, Integer value) {
        map.put(key, value);
    }

    public Integer get(String key) {
        return map.get(key);
    }
}

避免在持有锁的情况下执行耗时操作： 持有锁的时间越长，其他线程等待锁的时间就越长，死锁的风险也就越高。因此，应该尽量避免在持有锁的情况下执行耗时的操作，例如网络请求、数据库查询等。可以将这些耗时操作放在锁外面执行，或者使用异步方式执行。

示例：

死锁风险代码：

public class DatabaseOperation {
  private final Object lock = new Object();

  public void processData(String data) {
    synchronized (lock) {
      // 模拟耗时的数据库查询
      String result = queryDatabase(data);
      // 处理查询结果
      processResult(result);
    }
  }

  private String queryDatabase(String data) {
    // 模拟数据库查询
    try {
      Thread.sleep(2000); // 模拟查询耗时
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
    return "Result for " + data;
  }

  private void processResult(String result) {
    // 处理结果
    System.out.println("Processed: " + result);
  }
}

优化后的代码：

public class DatabaseOperation {
  private final Object lock = new Object();

  public void processData(String data) {
    // 在锁外面执行耗时的数据库查询
    String result = queryDatabase(data);
    synchronized (lock) {
      // 处理查询结果
      processResult(result);
    }
  }

  private String queryDatabase(String data) {
    // 模拟数据库查询
    try {
      Thread.sleep(2000); // 模拟查询耗时
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
    return "Result for " + data;
  }

  private void processResult(String result) {
    // 处理结果
    System.out.println("Processed: " + result);
  }
}

死锁的预防胜于治疗

编写多线程代码时，应该时刻注意死锁的风险，并采取相应的措施来预防死锁的发生。良好的代码设计、合理的锁使用、以及对并发容器的熟练掌握，都是避免死锁的关键。

总结：诊断与修复死锁的关键

理解死锁的根本原因，熟练运用JStack分析线程快照，并掌握常见的死锁修复策略，这都是排查和解决Java多线程死锁问题的关键。记住，预防胜于治疗，编写高质量的多线程代码才能从根本上避免死锁的发生。