// 基于本地 JDK 源码仓 (JDK 25), java.base/java/lang/Thread.java —— 启动与状态
public class Thread implements Runnable {

    // start 只能调一次。真正的"创建 OS 线程"在 native 的 start0 里，run() 由新线程回调
    public void start() {
        synchronized (this) {           // 锁 this 防止两个线程同时 start
            if (holder.threadStatus != 0)   // 非 0 说明已启动过（哪怕已经跑完），再调直接抛异常
                throw new IllegalThreadStateException();
            start0();
        }
    }

    private native void start0();       // 向内核要线程的地方。它异步启动新执行流，由新线程回调 run()

    // run 只是普通方法！手动调 thread.run() 就在当前线程同步执行，不会开新线程
    @Override
    public void run() {
        Runnable task = holder.task;
        if (task != null) {
            Object bindings = scopedValueBindings();
            runWith(bindings, task);    // 最终就是 op.run()，多出来的是 ScopedValue 绑定的栈上锚定
        }
    }

    public final boolean isAlive() {
        return alive();
    }

    boolean alive() {
        return eetop != 0;              // 活着 = VM 侧 JavaThread 还在。比查状态枚举更底层、更快
    }

    // 6 种状态，是 JVM 视角的状态机，和 OS 线程状态不一一对应
    public enum State {
        NEW,            // 还没 start
        RUNNABLE,       // 可运行。OS 层面的"就绪"和"运行中"Java 不细分，都算 RUNNABLE
        BLOCKED,        // 等 monitor 锁（synchronized 抢锁失败）
        WAITING,        // 无限期等待：wait()/join()/LockSupport.park()，要靠别人唤醒
        TIMED_WAITING,  // 限时等待：sleep(n)/wait(n)/join(n)/parkNanos
        TERMINATED;     // 跑完了，不可复活
    }

    public State getState() {
        return threadState();
    }

    State threadState() {
        return jdk.internal.misc.VM.toThreadState(holder.threadStatus);    // 状态真身是 VM 写的 threadStatus 位，这里只做翻译
    }
}

// 基于本地 JDK 源码仓 (JDK 25), java.base/java/lang/Thread.java —— 中断、sleep、join
public class Thread implements Runnable {

    // 中断 = 协作式通知，不是强杀。做两件事：置标志位 + 叫醒可能阻塞着的目标线程
    public void interrupt() {
        interrupted = true;             // 必须先置标志再通知，否则被唤醒的线程可能看不到中断原因
        interrupt0();                   // native：通知 VM，把阻塞在 sleep/wait/park 上的线程唤醒
        if (this != Thread.currentThread()) {
            Interruptible blocker;
            synchronized (interruptLock) {
                blocker = nioBlocker;   // 线程若阻塞在 NIO 可中断通道上，走通道自己的中断协议（关通道+抛 ClosedByInterruptException）
                if (blocker != null) {
                    blocker.interrupt(this);
                }
            }
            if (blocker != null) {
                blocker.postInterrupt();
            }
        }
    }

    // 静态方法，查"当前线程"并清除标志。连续调两次，第二次多半是 false
    public static boolean interrupted() {
        return currentThread().getAndClearInterrupt();
    }

    // 实例方法，只查不清。循环里响应中断用它：while (!isInterrupted()) {...}
    public boolean isInterrupted() {
        return interrupted;
    }

    boolean getAndClearInterrupt() {
        boolean oldValue = interrupted;
        if (oldValue) {                 // 只有确认看到 true 才清零。若无脑写 false，读和写之间新来的中断会被吞掉
            interrupted = false;
            clearInterruptEvent();
        }
        return oldValue;
    }

    // sleep：当前线程睡指定时长，不释放任何锁（和 wait 的本质区别）
    public static void sleep(long millis) throws InterruptedException {
        if (millis < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }
        long nanos = MILLISECONDS.toNanos(millis);
        sleepNanos(nanos);
    }

    private static void sleepNanos(long nanos) throws InterruptedException {
        ThreadSleepEvent event = beforeSleep(nanos);    // JFR 埋点
        try {
            if (currentThread() instanceof VirtualThread vthread) {
                vthread.sleepNanos(nanos);  // 虚拟线程：卸载出载体线程，不占内核线程干等
            } else {
                sleepNanos0(nanos);         // 平台线程：native，内核级挂起
            }
        } finally {
            afterSleep(event);
        }
    }

    // join：等目标线程死。实现就是在目标 Thread 对象的 monitor 上 wait，线程终止时 VM 会在该对象上 notifyAll
    public final void join(long millis) throws InterruptedException {
        if (millis < 0)
            throw new IllegalArgumentException("timeout value is negative");

        if (this instanceof VirtualThread vthread) {
            if (isAlive()) {
                long nanos = MILLISECONDS.toNanos(millis);
                vthread.joinNanos(nanos);
            }
            return;
        }

        synchronized (this) {               // 锁的是目标线程对象 —— 所以业务代码别在 Thread 实例上 wait/notify，会跟 join 打架
            if (millis > 0) {
                if (isAlive()) {
                    final long startTime = System.nanoTime();
                    long delay = millis;
                    do {
                        wait(delay);
                    } while (isAlive() && (delay = millis -    // 醒来必须重查 isAlive 并重算剩余时间：防虚假唤醒 + 防别人乱 notify
                             NANOSECONDS.toMillis(System.nanoTime() - startTime)) > 0);
                }
            } else {
                while (isAlive()) {         // millis=0 表示无限等，同样必须循环检查
                    wait(0);
                }
            }
        }
    }
}