《Java 并发编程·性能诊断与事故》4.1 死锁的四个必要条件与检测

import java.lang.management.ManagementFactory;
import java.lang.management.ThreadInfo;
import java.lang.management.ThreadMXBean;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 构造一个 Java 级死锁（ReentrantLock 版本），并用 ThreadMXBean 做看门狗。
 * 四个必要条件逐条落在代码里：
 *   1. 互斥   —— LOCK_A / LOCK_B 是 ReentrantLock，同一时刻只允许一个线程持有；
 *   2. 持有等待—— transfer 先 lock(from)，再 lock(to)，持有 from 期间等 to；
 *   3. 不可剥夺—— Lock.lock() 不可被抢占，只能等持有者 unlock；
 *   4. 循环等待—— t1 按 A→B 加锁，t2 按 B→A 加锁。
 */
public final class DeadlockLab {

    private static final ReentrantLock LOCK_A = new ReentrantLock();
    private static final ReentrantLock LOCK_B = new ReentrantLock();

    public static void main(String[] args) throws Exception {
        Thread t1 = Thread.ofPlatform().name("transfer-1").start(() -> transfer(LOCK_A, LOCK_B));
        Thread t2 = Thread.ofPlatform().name("transfer-2").start(() -> transfer(LOCK_B, LOCK_A));
        Thread watchdog = Thread.ofPlatform().name("deadlock-watchdog").daemon(true)
                .start(DeadlockLab::watch);
        System.out.println("pid=" + ProcessHandle.current().pid()
                + " t1=" + t1.threadId() + " t2=" + t2.threadId()
                + " watchdog=" + watchdog.threadId());
        t1.join();
        t2.join();
        System.out.println("both transfers finished");
    }

    private static void transfer(ReentrantLock from, ReentrantLock to) {
        from.lock();                       // 条件 1 + 条件 2：持有 from
        try {
            sleep(300);                    // 让两个线程都先拿到第一把锁
            to.lock();                     // 条件 3：不可剥夺，只能等
            try {
                System.out.println(Thread.currentThread().getName() + " acquired both");
            } finally {
                to.unlock();
            }
        } finally {
            from.unlock();
        }
    }

    private static void watch() {
        ThreadMXBean mx = ManagementFactory.getThreadMXBean();
        System.out.println("deadlock detection supported=" + mx.isSynchronizerUsageSupported());
        while (true) {
            sleep(2000);
            long[] ids = mx.findDeadlockedThreads();   // null 表示当前没有环
            if (ids == null) {
                System.out.println("[watchdog] no deadlock");
                continue;
            }
            System.out.println("[watchdog] findDeadlockedThreads -> " + java.util.Arrays.toString(ids));
            for (ThreadInfo info : mx.getThreadInfo(ids, true, true)) {
                System.out.println("[watchdog] thread=" + info.getThreadName()
                        + " id=" + info.getThreadId()
                        + " state=" + info.getThreadState()
                        + " waitingOn=" + info.getLockName()
                        + " owner=" + info.getLockOwnerName());
                StackTraceElement[] st = info.getStackTrace();
                for (int i = 0; i < Math.min(4, st.length); i++) {
                    System.out.println("[watchdog]   at " + st[i]);
                }
            }
        }
    }

    private static void sleep(long millis) {
        try {
            Thread.sleep(millis);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

javac --release 25 -d classes DeadlockLab.java
java -cp classes DeadlockLab > out/watchdog.txt 2>&1 &
PID=$!
sleep 4
jcmd "$PID" Thread.print -l > out/deadlock-dump.txt

Found one Java-level deadlock:
=============================
"transfer-1":
  waiting for ownable synchronizer 0x000000035fc19a30, (a java.util.concurrent.locks.ReentrantLock$NonfairSync),
  which is held by "transfer-2"

"transfer-2":
  waiting for ownable synchronizer 0x000000035fc19a00, (a java.util.concurrent.locks.ReentrantLock$NonfairSync),
  which is held by "transfer-1"

"transfer-1" #25 [28163] prio=5 os_prio=31 cpu=0.33ms elapsed=7.35s tid=0x000000089b51f800 nid=28163 waiting on condition  [0x0000000171cae000]
   java.lang.Thread.State: WAITING (parking)
	at jdk.internal.misc.Unsafe.park(java.base@25.0.5/Native Method)
	- parking to wait for  <0x000000035fc19a30> (a java.util.concurrent.locks.ReentrantLock$NonfairSync)
	at java.util.concurrent.locks.LockSupport.park(java.base@25.0.5/LockSupport.java:223)
	at java.util.concurrent.locks.ReentrantLock.lock(java.base@25.0.5/ReentrantLock.java:323)
	at DeadlockLab.transfer(DeadlockLab.java:36)
	at DeadlockLab.lambda$main$0(DeadlockLab.java:20)

   Locked ownable synchronizers:
	- <0x000000035fc19a00> (a java.util.concurrent.locks.ReentrantLock$NonfairSync)

pid=82070 t1=25 t2=26 watchdog=27
deadlock detection supported=true
[watchdog] findDeadlockedThreads -> [25, 26]
[watchdog] thread=transfer-1 id=25 state=WAITING waitingOn=java.util.concurrent.locks.ReentrantLock$NonfairSync@3f2c5530 owner=transfer-2
[watchdog]   at java.base@25.0.5/jdk.internal.misc.Unsafe.park(Native Method)
[watchdog]   at java.base@25.0.5/java.util.concurrent.locks.LockSupport.park(LockSupport.java:223)
[watchdog]   at java.base@25.0.5/java.util.concurrent.locks.AbstractQueuedSynchronizer.acquire(AbstractQueuedSynchronizer.java:790)
[watchdog] thread=transfer-2 id=26 state=WAITING waitingOn=java.util.concurrent.locks.ReentrantLock$NonfairSync@49e8650 owner=transfer-1

import java.lang.management.ManagementFactory;
import java.lang.management.ThreadInfo;
import java.lang.management.ThreadMXBean;
import java.util.Arrays;

public final class DeadlockWatchdog implements Runnable {
    private final ThreadMXBean mx = ManagementFactory.getThreadMXBean();
    private final long intervalMillis;
    private long[] lastSeen;

    public DeadlockWatchdog(long intervalMillis) {
        this.intervalMillis = intervalMillis;
    }

    @Override
    public void run() {
        while (!Thread.currentThread().isInterrupted()) {
            try {
                Thread.sleep(intervalMillis);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                return;
            }
            long[] ids = mx.findDeadlockedThreads();
            if (ids == null) {
                lastSeen = null;
                continue;
            }
            long[] sorted = ids.clone();
            Arrays.sort(sorted);
            if (lastSeen != null && Arrays.equals(sorted, lastSeen)) {
                report(sorted);
            } else {
                lastSeen = sorted;
            }
        }
    }

    private void report(long[] ids) {
        System.err.println("sustained deadlock: " + Arrays.toString(ids));
        for (ThreadInfo info : mx.getThreadInfo(ids, true, true)) {
            if (info == null) {
                continue;
            }
            System.err.println("  " + info.getThreadName()
                    + " waits on " + info.getLockName()
                    + " owned by " + info.getLockOwnerName());
        }
    }
}

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public final class DeadlockMonitor {
    private final ScheduledExecutorService scheduler =
            Executors.newSingleThreadScheduledExecutor(r -> {
                Thread t = Thread.ofPlatform().name("deadlock-watchdog").unstarted(r);
                t.setDaemon(true);
                return t;
            });

    public void start() {
        scheduler.scheduleWithFixedDelay(new DeadlockWatchdog(2000),
                2, 2, TimeUnit.SECONDS);
    }

    public void stop() {
        scheduler.shutdownNow();
    }
}