BLOCKED·WAITING 상태로 스레드 덤프 읽기

import java.util.concurrent.CountDownLatch;

public final class MonitorStateTimeline {
    private final Object monitor = new Object();
    private final CountDownLatch ownerEntered = new CountDownLatch(1);
    private boolean released;

    void waitForRelease() throws InterruptedException {
        synchronized (monitor) {
            ownerEntered.countDown();
            Thread.sleep(80);
            while (!released) monitor.wait();
        }
    }

    void release() throws InterruptedException {
        ownerEntered.await();
        synchronized (monitor) {
            released = true;
            monitor.notifyAll();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        MonitorStateTimeline timeline = new MonitorStateTimeline();
        Thread owner = Thread.ofPlatform().name("owner-then-waiter").start(() -> {
            try { timeline.waitForRelease(); }
            catch (InterruptedException e) { Thread.currentThread().interrupt(); }
        });
        timeline.ownerEntered.await();
        Thread entrant = Thread.ofPlatform().name("entrant").start(() -> {
            try { timeline.release(); }
            catch (InterruptedException e) { Thread.currentThread().interrupt(); }
        });
        Thread.sleep(20);
        System.out.println("during-hold=" + entrant.getState());
        owner.join();
        entrant.join();
        System.out.println("owner-final=" + owner.getState());
        System.out.println("entrant-final=" + entrant.getState());
    }
}

during-hold=BLOCKED
owner-final=TERMINATED
entrant-final=TERMINATED

public final class ThreadStateHandshake {
    private final Object gate = new Object();
    private boolean open;

    void awaitOpen() throws InterruptedException {
        synchronized (gate) {
            while (!open) gate.wait();
        }
    }

    void open() {
        synchronized (gate) {
            open = true;
            gate.notifyAll();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        ThreadStateHandshake demo = new ThreadStateHandshake();
        Thread worker = Thread.ofPlatform().start(() -> {
            try { demo.awaitOpen(); }
            catch (InterruptedException e) { Thread.currentThread().interrupt(); }
        });
        while (worker.getState() != Thread.State.WAITING) {
            Thread.onSpinWait();
        }
        demo.open();
        worker.join();
        System.out.println("done=" + !worker.isAlive());
    }
}

done=true

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

public final class LatchHandshake {
    private final Object gate = new Object();
    private final CountDownLatch reached = new CountDownLatch(1);
    private boolean open;

    void awaitOpen() throws InterruptedException {
        reached.countDown(); // "여기까지 왔다"는 사실을 래치에 남깁니다
        synchronized (gate) {
            while (!open) gate.wait();
        }
    }

    void open() {
        synchronized (gate) {
            open = true;
            gate.notifyAll();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        LatchHandshake demo = new LatchHandshake();
        Thread worker = Thread.ofPlatform().start(() -> {
            try { demo.awaitOpen(); }
            catch (InterruptedException e) { Thread.currentThread().interrupt(); }
        });
        boolean reached = demo.reached.await(1, TimeUnit.SECONDS);
        System.out.println("reached=" + reached);
        demo.open();
        worker.join();
        System.out.println("done=" + !worker.isAlive());
    }
}

reached=true
done=true

import java.util.List;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public final class WaitingThreadsDemo {
    private static final Object monitor = new Object();
    private static final Object gate = new Object();
    private static final ReentrantLock lock = new ReentrantLock();
    private static final Condition notEmpty = lock.newCondition();
    private static boolean gateOpen;  // gate가 보호합니다. 이 예제에서는 끝내 true가 되지 않습니다.
    private static boolean itemReady; // lock이 보호합니다. 역시 true가 되지 않습니다.

    private static Thread start(String name, Runnable task) throws InterruptedException {
        Thread thread = Thread.ofPlatform().daemon().name(name).start(task);
        Thread.sleep(100); // 다음 스레드를 시작하기 전에 이 스레드가 자리를 잡을 시간을 줍니다
        return thread;
    }

    private static void sleepLong() {
        try {
            Thread.sleep(60_000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        List<Thread> threads = List.of(
                start("owner", () -> {
                    synchronized (monitor) { sleepLong(); }
                }),
                start("entrant", () -> {
                    synchronized (monitor) { }
                }),
                start("waiter", () -> {
                    synchronized (gate) {
                        try {
                            while (!gateOpen) gate.wait();
                        } catch (InterruptedException e) {
                            Thread.currentThread().interrupt();
                        }
                    }
                }),
                start("consumer", () -> {
                    lock.lock();
                    try {
                        while (!itemReady) notEmpty.await();
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                    } finally {
                        lock.unlock();
                    }
                }),
                start("lock-owner", () -> {
                    lock.lock();
                    try { sleepLong(); } finally { lock.unlock(); }
                }),
                start("lock-entrant", () -> {
                    lock.lock();
                    lock.unlock();
                }));

        for (Thread thread : threads) {
            System.out.printf("%-12s %s%n", thread.getName(), thread.getState());
        }
        System.out.println("pid=" + ProcessHandle.current().pid());
        Thread.sleep(30_000); // 이 사이에 다른 터미널에서 스레드 덤프를 뜹니다
    }
}

owner        TIMED_WAITING
entrant      BLOCKED
waiter       WAITING
consumer     WAITING
lock-owner   TIMED_WAITING
lock-entrant WAITING
pid=22802

"owner" #18 [22821] daemon prio=5 os_prio=0 cpu=0.22ms elapsed=1.73s tid=0x00007ff61863f3a0 nid=22821 waiting on condition  [0x00007ff61ca18000]
   java.lang.Thread.State: TIMED_WAITING (sleeping)
	at java.lang.Thread.sleep0([email protected]/Native Method)
	at java.lang.Thread.sleep([email protected]/Thread.java:509)
	at WaitingThreadsDemo.sleepLong(WaitingThreadsDemo.java:21)
	at WaitingThreadsDemo.lambda$main$0(WaitingThreadsDemo.java:30)
	- locked <0x00000000a851a8d8> (a java.lang.Object)
	...

"entrant" #19 [22843] daemon prio=5 os_prio=0 cpu=0.30ms elapsed=1.63s tid=0x00007ff618640aa0 nid=22843 waiting for monitor entry  [0x00007ff61c918000]
   java.lang.Thread.State: BLOCKED (on object monitor)
	at WaitingThreadsDemo.lambda$main$1(WaitingThreadsDemo.java:33)
	- waiting to lock <0x00000000a851a8d8> (a java.lang.Object)
	...

"waiter" #20 [22845] daemon prio=5 os_prio=0 cpu=0.28ms elapsed=1.53s tid=0x00007ff618641e10 nid=22845 in Object.wait()  [0x00007ff61c818000]
   java.lang.Thread.State: WAITING (on object monitor)
	at java.lang.Object.wait0([email protected]/Native Method)
	- waiting on <0x00000000a851a8e8> (a java.lang.Object)
	at java.lang.Object.wait([email protected]/Object.java:366)
	at java.lang.Object.wait([email protected]/Object.java:339)
	at WaitingThreadsDemo.lambda$main$2(WaitingThreadsDemo.java:38)
	- locked <0x00000000a851a8e8> (a java.lang.Object)
	...

"consumer" #21 [22846] daemon prio=5 os_prio=0 cpu=1.83ms elapsed=1.43s tid=0x00007ff618642fe0 nid=22846 waiting on condition  [0x00007ff61c718000]
   java.lang.Thread.State: WAITING (parking)
	at jdk.internal.misc.Unsafe.park([email protected]/Native Method)
	- parking to wait for  <0x00000000a851a9f0> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject)
	...
	at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await([email protected]/AbstractQueuedSynchronizer.java:1746)
	at WaitingThreadsDemo.lambda$main$3(WaitingThreadsDemo.java:47)
	...

"lock-owner" #22 [22847] daemon prio=5 os_prio=0 cpu=0.24ms elapsed=1.32s tid=0x00007ff618644200 nid=22847 waiting on condition  [0x00007ff61c618000]
   java.lang.Thread.State: TIMED_WAITING (sleeping)
	...
	at WaitingThreadsDemo.lambda$main$4(WaitingThreadsDemo.java:56)
	...

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

"lock-entrant" #23 [22870] daemon prio=5 os_prio=0 cpu=0.32ms elapsed=1.22s tid=0x00007ff6186455e0 nid=22870 waiting on condition  [0x00007ff61c518000]
   java.lang.Thread.State: WAITING (parking)
	at jdk.internal.misc.Unsafe.park([email protected]/Native Method)
	- parking to wait for  <0x00000000a851a9d0> (a java.util.concurrent.locks.ReentrantLock$NonfairSync)
	...
	at java.util.concurrent.locks.ReentrantLock.lock([email protected]/ReentrantLock.java:322)
	at WaitingThreadsDemo.lambda$main$5(WaitingThreadsDemo.java:59)
	...

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

public final class NestedMonitorStall {
    private final Object outer = new Object();
    private final Object inner = new Object();
    private boolean ready;

    void awaitReady() throws InterruptedException {
        synchronized (outer) {
            synchronized (inner) {
                while (!ready) inner.wait(); // inner만 내려놓고 outer는 계속 쥐고 있습니다
            }
        }
    }

    void markReady() {
        synchronized (outer) {               // waiter가 쥔 outer 앞에서 멈춥니다
            synchronized (inner) {
                ready = true;
                inner.notifyAll();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        NestedMonitorStall stall = new NestedMonitorStall();
        Thread waiter = Thread.ofPlatform().daemon().name("waiter").start(() -> {
            try { stall.awaitReady(); }
            catch (InterruptedException e) { Thread.currentThread().interrupt(); }
        });
        Thread.sleep(100);
        Thread marker = Thread.ofPlatform().daemon().name("marker").start(stall::markReady);
        Thread.sleep(100);
        System.out.println("waiter=" + waiter.getState() + " marker=" + marker.getState());
        long[] deadlocked = ManagementFactory.getThreadMXBean().findDeadlockedThreads();
        System.out.println("deadlocked=" + Arrays.toString(deadlocked));
    }
}

waiter=WAITING marker=BLOCKED
deadlocked=null

import java.lang.management.LockInfo;
import java.lang.management.ManagementFactory;
import java.lang.management.ThreadInfo;
import java.lang.management.ThreadMXBean;
import java.util.EnumSet;

public final class WaitingThreadReporter {
    private static final EnumSet<Thread.State> WAIT_STATES = EnumSet.of(
            Thread.State.BLOCKED,
            Thread.State.WAITING,
            Thread.State.TIMED_WAITING);

    static void report() {
        ThreadMXBean bean = ManagementFactory.getThreadMXBean();
        ThreadInfo[] infos = bean.dumpAllThreads(true, true);
        for (ThreadInfo info : infos) {
            if (info == null || !WAIT_STATES.contains(info.getThreadState())) continue;
            LockInfo lock = info.getLockInfo();
            StackTraceElement[] stack = info.getStackTrace();
            String top = stack.length == 0 ? "<no-frame>" : stack[0].toString();
            System.out.printf("name=%s state=%s lock=%s owner=%s top=%s%n",
                    info.getThreadName(), info.getThreadState(), lock,
                    info.getLockOwnerName(), top);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread sleeper = Thread.ofPlatform().name("diagnostic-sleeper").start(() -> {
            try { Thread.sleep(200); }
            catch (InterruptedException e) { Thread.currentThread().interrupt(); }
        });
        report();
        sleeper.join();
    }
}

name=Finalizer state=WAITING lock=java.lang.ref.NativeReferenceQueue$Lock@548c4f57 owner=null [email protected]/java.lang.Object.wait0(Native Method)
name=Common-Cleaner state=TIMED_WAITING lock=java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject@214c265e owner=null [email protected]/jdk.internal.misc.Unsafe.park(Native Method)
name=diagnostic-sleeper state=TIMED_WAITING lock=null owner=null [email protected]/java.lang.Thread.sleep0(Native Method)

"waiter" #18 [1805] prio=5 os_prio=0 cpu=0.18ms elapsed=1.82s tid=0x00007f475863e830 nid=1805 in Object.wait()  [0x00007f47318fe000]
   java.lang.Thread.State: BLOCKED (on object monitor)
	at java.lang.Object.wait0([email protected]/Native Method)
	- waiting to re-lock in wait() <0x00000000a8519218> (a java.lang.Object)
	at java.lang.Object.wait([email protected]/Object.java:366)
	at java.lang.Object.wait([email protected]/Object.java:339)
	at NotifyHoldsMonitor.lambda$main$0(NotifyHoldsMonitor.java:9)
	- locked <0x00000000a8519218> (a java.lang.Object)