Java 程序死锁问题：原因、排查与解决方案

最新推荐文章于 2025-04-30 08:46:31 发布

梦幻南瓜

最新推荐文章于 2025-04-30 08:46:31 发布

阅读量608

点赞数 4

分类专栏： java 文章标签： java 开发语言死锁

本文链接：https://blog.youkuaiyun.com/ybg8912/article/details/145676818

版权

java 专栏收录该内容

195 篇文章

订阅专栏

在多线程编程中，死锁（Deadlock）是一个常见且棘手的问题。当多个线程相互等待对方释放资源时，程序可能会陷入无限等待的状态，导致系统无法继续运行。本文将深入探讨 Java 程序中死锁的成因、如何排查死锁问题，并提供有效的解决方案，帮助你编写更健壮的多线程程序。

什么是死锁？
死锁是指两个或多个线程在执行过程中，因争夺资源而造成的一种互相等待的现象。如果没有外部干预，这些线程将永远无法继续执行。死锁通常发生在以下四个条件同时满足时：

互斥条件：资源一次只能被一个线程占用。
占有并等待：线程持有资源的同时，还在等待其他资源。
非抢占条件：线程已占用的资源不能被其他线程强行抢占。
循环等待条件：多个线程之间形成一种头尾相接的循环等待关系。

死锁的示例
以下是一个典型的 Java 死锁示例：

public class DeadlockExample {
    private static final Object resource1 = new Object();
    private static final Object resource2 = new Object();

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            synchronized (resource1) {
                System.out.println("Thread 1: Holding resource 1...");
                try { Thread.sleep(100); } catch (InterruptedException e) {}
                System.out.println("Thread 1: Waiting for resource 2...");
                synchronized (resource2) {
                    System.out.println("Thread 1: Acquired resource 2!");
                }
            }
        });

        Thread thread2 = new Thread(() -> {
            synchronized (resource2) {
                System.out.println("Thread 2: Holding resource 2...");
                try { Thread.sleep(100); } catch (InterruptedException e) {}
                System.out.println("Thread 2: Waiting for resource 1...");
                synchronized (resource1) {
                    System.out.println("Thread 2: Acquired resource 1!");
                }
            }
        });

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

运行结果
程序会输出以下内容，然后陷入死锁状态：

Thread 1: Holding resource 1...
Thread 2: Holding resource 2...
Thread 1: Waiting for resource 2...
Thread 2: Waiting for resource 1...

如何排查死锁？
1. 使用工具检测死锁
Java 提供了多种工具来检测死锁，例如：

jstack：通过命令行工具 jstack 可以查看线程的堆栈信息，分析是否存在死锁。
VisualVM：图形化工具，可以实时监控线程状态，检测死锁。

-分析线程堆栈
通过线程堆栈信息，可以清晰地看到哪些线程在等待哪些资源。例如，使用 jstack 输出的死锁信息如下：

Found one Java-level deadlock:
=============================
Thread 1:
  waiting to lock monitor 0x00007f8b1c0001e8 (object 0x000000076ab2c1d8, a java.lang.Object),
  which is held by Thread 2

Thread 2:
  waiting to lock monitor 0x00007f8b1c0002e8 (object 0x000000076ab2c1e8, a java.lang.Object),
  which is held by Thread 1

解决死锁的常见方法
1. 避免嵌套锁
尽量减少嵌套锁的使用，确保线程以一致的顺序获取资源。例如，修改上述示例代码：

public class DeadlockSolution {
    private static final Object resource1 = new Object();
    private static final Object resource2 = new Object();

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            synchronized (resource1) {
                System.out.println("Thread 1: Holding resource 1...");
                try { Thread.sleep(100); } catch (InterruptedException e) {}
                synchronized (resource2) {
                    System.out.println("Thread 1: Acquired resource 2!");
                }
            }
        });

        Thread thread2 = new Thread(() -> {
            synchronized (resource1) {
                System.out.println("Thread 2: Holding resource 1...");
                try { Thread.sleep(100); } catch (InterruptedException e) {}
                synchronized (resource2) {
                    System.out.println("Thread 2: Acquired resource 2!");
                }
            }
        });

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

2. 使用超时机制
在获取锁时设置超时时间，避免无限等待。例如，使用 ReentrantLock 的 tryLock 方法：

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

public class TimeoutSolution {
    private static final Lock lock1 = new ReentrantLock();
    private static final Lock lock2 = new ReentrantLock();

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            try {
                if (lock1.tryLock(100, TimeUnit.MILLISECONDS)) {
                    System.out.println("Thread 1: Holding lock 1...");
                    try { Thread.sleep(100); } catch (InterruptedException e) {}
                    if (lock2.tryLock(100, TimeUnit.MILLISECONDS)) {
                        System.out.println("Thread 1: Acquired lock 2!");
                        lock2.unlock();
                    }
                    lock1.unlock();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        Thread thread2 = new Thread(() -> {
            try {
                if (lock2.tryLock(100, TimeUnit.MILLISECONDS)) {
                    System.out.println("Thread 2: Holding lock 2...");
                    try { Thread.sleep(100); } catch (InterruptedException e) {}
                    if (lock1.tryLock(100, TimeUnit.MILLISECONDS)) {
                        System.out.println("Thread 2: Acquired lock 1!");
                        lock1.unlock();
                    }
                    lock2.unlock();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

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