JVM jstack实战之死锁问题详解

什么是死锁

死锁指的是两个或多个进程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法继续执行下去。

如何检测死锁

在 Java 中，可以使用 jstack 命令检测死锁。使用指令 jstack <pid> 可以查看指定进程的堆栈信息， 进而分析出是否存在死锁。

如何解决死锁问题

处理死锁最常见的办法有两种，一种是撤销进程，将资源让给其他进程；另一种是终止进程，强制结束进程。

示例一

下面是一个简单的死锁示例：

public class DeadLockDemo {
    private static Object lockA = new Object();
    private static Object lockB = new Object();

    public static void main(String[] args) {
        Thread t1 = new Thread(new Runnable() {
            public void run() {
                synchronized (lockA) {
                    try {
                        Thread.sleep(1000L);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (lockB) {
                        System.out.println("Thread1");
                    }
                }
            }
        });

        Thread t2 = new Thread(new Runnable() {
            public void run() {
                synchronized (lockB) {
                    synchronized (lockA) {
                        System.out.println("Thread2");
                    }
                }
            }
        });

        t1.start();
        t2.start();
    }
}

当运行该程序时，两个线程会互相持有对方需要的锁，导致死锁。使用 jstack 命令查看进程堆栈信息，即可发现出现了死锁现象。

示例二

下面是另一个死锁示例：

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

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

    public static void main(String[] args) {
        Thread t1 = new Thread(new Runnable() {
            public void run() {
                lockA.lock();
                try {
                    Thread.sleep(1000L);
                    lockB.lock();
                    System.out.println("Thread1");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lockB.unlock();
                    lockA.unlock();
                }
            }
        });

        Thread t2 = new Thread(new Runnable() {
            public void run() {
                lockB.lock();
                try {
                    Thread.sleep(1000L);
                    lockA.lock();
                    System.out.println("Thread2");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lockA.unlock();
                    lockB.unlock();
                }
            }
        });

        t1.start();
        t2.start();
    }
}

当运行该程序时，同样会出现死锁现象。使用 jstack 命令查看进程堆栈信息，可以发现线程1持有锁A等待锁B，而线程2持有锁B等待锁A，从而形成了死锁。

总之，死锁问题需要及时发现，否则会对系统的正常运行产生非常大的影响。使用 jstack 命令可以快速定位死锁问题，进而解决。