如果一个线上运行的程序，出现了死锁，应该怎么处理

文章目录

• 确认死锁
• 定位死锁原因
• 采取临时措施
• 根本解决措施
• • 分析代码
  • 解决方案

确认死锁

首先，使用 jstack 工具确认确实存在死锁。通过以下步骤来生成线程堆栈信息：

jstack <pid> > threaddump.txt

其中 pid 是目标 JVM 进程的 ID。生成的文件 threaddump.txt 会包含所有线程的堆栈信息，包含死锁信息的部分通常带有诸如 “Found one Java-level deadlock” 的提示。

定位死锁原因

打开 threaddump.txt 文件，找到死锁相关的信息。以下是一个死锁信息的示例：

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

从中我们可以看到，Thread-1 和 Thread-2 互相等待对方持有的锁。

采取临时措施

可以采取以下临时措施来缓解或解决当前的死锁问题：

1、重启服务：这是最直接的方法，但要注意这样的方法只是暂时缓解问题，不能从根本上解决死锁。
2、业务降级：根据具体情况，考虑关闭或暂时停止某些不重要的功能和服务，减轻系统负担，避免更多的死锁情况出现。

根本解决措施

分析代码

根据堆栈信息，查找系统中涉及死锁的代码片段，了解线程执行的具体逻辑及其锁机制。例如：

public class DeadlockDemo {
    private final Object lock1 = new Object();
    private final Object lock2 = new Object();

    public void method1() {
        synchronized (lock1) {
            // Simulate work
            try { Thread.sleep(50); } catch (InterruptedException e) {}
            synchronized (lock2) {
                System.out.println("method1");
            }
        }
    }

    public void method2() {
        synchronized (lock2) {
            // Simulate work
            try { Thread.sleep(50); } catch (InterruptedException e) {}
            synchronized (lock1) {
                System.out.println("method2");
            }
        }
    }
}

解决方案

调整锁的顺序

确保所有线程以相同的顺序获取锁，从而防止循环等待。例如，上述例子可以调整方法中的锁顺序：

public void method1() {
    synchronized (lock1) {
        synchronized (lock2) {
            System.out.println("method1");
        }
    }
}

public void method2() {
    synchronized (lock1) {
        synchronized (lock2) {
            System.out.println("method2");
        }
    }
}

使用 tryLock 和超时

使用 java.util.concurrent.locks.ReentrantLock 类中的 tryLock 方法，只在资源可用时才获取锁（如果没有可用资源，则返回false，继续执行其他业务），并设置获取锁的超时时间，以防长时间等待。

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

public class DeadlockFree {

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

    public void method1() {
        try {
            if (lock1.tryLock(1000, TimeUnit.MILLISECONDS)) {
                try {
                    if (lock2.tryLock(1000, TimeUnit.MILLISECONDS)) {
                        try {
                            System.out.println("method1");
                        } finally {
                            lock2.unlock();
                        }
                    }
                } finally {
                    lock1.unlock();
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public void method2() {
        try {
            if (lock2.tryLock(1000, TimeUnit.MILLISECONDS)) {
                try {
                    if (lock1.tryLock(1000, TimeUnit.MILLISECONDS)) {
                        try {
                            System.out.println("method2");
                        } finally {
                            lock1.unlock();
                        }
                    }
                } finally {
                    lock2.unlock();
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}