Java 线程生命周期与状态转换的核心路径

public class ThreadStateDemo1 {
    public static void main(String[] args) throws InterruptedException {
        // 1. 创建线程，此时状态为 NEW
        Thread thread = new Thread(() -> {
            System.out.println("线程执行中，当前状态：" + Thread.currentThread().getState());
            // 模拟任务执行
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "基础状态线程");
        System.out.println("调用start()前，线程状态：" + thread.getState()); // NEW
        // 2. 启动线程，进入 RUNNABLE 状态
        thread.start();
        Thread.sleep(50); // 等待线程进入执行状态
        System.out.println("线程执行中，主线程观察到的状态：" + thread.getState()); // RUNNABLE
        // 3. 等待线程执行完毕
        thread.join();
        System.out.println("线程执行完毕，当前状态：" + thread.getState()); // TERMINATED
    }
}

public class ThreadStateDemo2 {
    // 定义一个锁对象
    private static final Object LOCK = new Object();
    public static void main(String[] args) throws InterruptedException {
        // 线程1：先获取锁，持有锁1秒
        Thread thread1 = new Thread(() -> {
            synchronized (LOCK) {
                try {
                    System.out.println(Thread.currentThread().getName() + " 获取到锁，状态：RUNNABLE");
                    Thread.sleep(1000); // 持有锁，让线程2阻塞
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "线程1");
        // 线程2：后获取锁，会进入 BLOCKED 状态
        Thread thread2 = new Thread(() -> {
            synchronized (LOCK) {
                System.out.println(Thread.currentThread().getName() + " 成功获取锁，状态回到 RUNNABLE");
            }
        }, "线程2");
        // 启动线程1和线程2
        thread1.start();
        Thread.sleep(100); // 确保线程1先获取锁
        thread2.start();
        // 观察线程2的状态
        Thread.sleep(200);
        System.out.println(thread2.getName() + " 等待锁，状态：" + thread2.getState()); // BLOCKED
        // 等待线程1执行完毕，线程2获取锁
        thread1.join();
        Thread.sleep(200);
        System.out.println(thread2.getName() + " 执行中，状态：" + thread2.getState()); // RUNNABLE
    }
}

public class ThreadStateDemo3 {
    private static final Object LOCK = new Object();
    private static Thread waitThread; // 等待线程
    public static void main(String[] args) throws InterruptedException {
        // 等待线程：调用wait()进入WAITING状态
        waitThread = new Thread(() -> {
            synchronized (LOCK) {
                try {
                    System.out.println(Thread.currentThread().getName() + " 调用wait()，进入WAITING状态");
                    LOCK.wait(); // 无参wait，释放锁
                    System.out.println(Thread.currentThread().getName() + " 被唤醒，状态回到RUNNABLE");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "等待线程");
        // 唤醒线程：调用notify()唤醒等待线程
        Thread notifyThread = new Thread(() -> {
            synchronized (LOCK) {
                System.out.println(Thread.currentThread().getName() + " 获取锁，准备唤醒等待线程");
                LOCK.notify(); // 唤醒等待线程
                try {
                    Thread.sleep(500); // 持有锁，让等待线程先处于WAITING→BLOCKED
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "唤醒线程");
        waitThread.start();
        Thread.sleep(200);
        System.out.println(waitThread.getName() + " 当前状态：" + waitThread.getState()); // WAITING
        notifyThread.start();
        notifyThread.join();
        Thread.sleep(200);
        System.out.println(waitThread.getName() + " 最终状态：" + waitThread.getState()); // RUNNABLE/TERMINATED
    }
}

public class ThreadStateDemo4 {
    public static void main(String[] args) throws InterruptedException {
        Thread sleepThread = new Thread(() -> {
            try {
                System.out.println(Thread.currentThread().getName() + " 调用sleep(1000)，进入TIMED_WAITING状态");
                Thread.sleep(1000); // 超时等待1秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + " 超时唤醒，状态回到RUNNABLE");
        }, "睡眠线程");
        sleepThread.start();
        Thread.sleep(200);
        System.out.println(sleepThread.getName() + " 当前状态：" + sleepThread.getState()); // TIMED_WAITING
        sleepThread.join();
        System.out.println(sleepThread.getName() + " 执行完毕，状态：" + sleepThread.getState()); // TERMINATED
    }
}

jps
# 输出示例：1234 ThreadStateDemo2 （1234为PID）

jstack 1234 > thread_dump.txt

"线程2" #13 prio=5 os_prio=31 tid=0x00007f8b1282e000 nid=0x5003 waiting for monitor entry [0x0000700001a6f000]
   java.lang.Thread.State: BLOCKED (on object monitor)
        at ThreadStateDemo2.lambda$main$1(ThreadStateDemo2.java:18)
        - waiting to lock <0x000000076ab81810> (a java.lang.Object)
        - locked <0x000000076ab81810> (a java.lang.Object)