// 基于 JDK 25 (本地 JAVA_Source 仓), java.lang.Object
public class Object {

    @IntrinsicCandidate         // JVM 内建实现：JIT 会用固化的快速版本替换调用，下同
    public Object() {}

    // final：运行时类型由 JVM 保证，子类不许伪造。返回的 Class 对象就是 static synchronized 方法锁的那个对象
    @IntrinsicCandidate
    public final native Class<?> getClass();

    // 默认实现是"身份哈希"：首次调用时生成并缓存进对象头 mark word，之后终身不变（GC 移动对象也不变）。
    // 契约：equals 相等 => hashCode 必须相等。只重写 equals 不重写 hashCode，对象进 HashMap 会散到不同桶，"存了却查不到"
    @IntrinsicCandidate
    public native int hashCode();

    // 默认语义 = 是不是同一个对象。按业务字段判等必须重写，且满足自反/对称/传递/一致
    public boolean equals(Object obj) {
        return (this == obj);
    }

    // 浅拷贝：逐字段复制，引用字段仍指向同一对象。protected + 要求实现 Cloneable 双重门槛，防止随手拷贝可变状态
    @IntrinsicCandidate
    protected native Object clone() throws CloneNotSupportedException;

    public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());   // 重写了 hashCode，这里的默认输出也跟着变
    }

    // ... wait/notify 线程协作部分见下一段 ...

    // 已废弃且待移除(JEP 421)：执行时机不可控、能复活对象、异常被吞。清理资源用 Cleaner 或 try-with-resources
    @Deprecated(since="9", forRemoval=true)
    protected void finalize() throws Throwable { }
}

// 基于 JDK 25 (本地 JAVA_Source 仓), java.lang.Object 线程协作部分

    // 从该对象的等待集(WaitSet)任选一个线程唤醒，选哪个由 JVM 决定，业务代码不能依赖顺序
    @IntrinsicCandidate
    public final native void notify();

    // 全部唤醒，各自重新抢锁、重查条件。多种线程等不同条件时只能用它，否则可能"唤醒错人"导致信号丢失
    @IntrinsicCandidate
    public final native void notifyAll();

    public final void wait() throws InterruptedException {
        wait(0L);                   // 0 = 不计时，等到被唤醒为止
    }

    // 坑：wait(long) 早已不是 native(JDK 19 起)。Java 层做参数校验和虚拟线程适配，真正的挂起在 native 的 wait0
    public final void wait(long timeoutMillis) throws InterruptedException {
        if (timeoutMillis < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }

        if (Thread.currentThread() instanceof VirtualThread vthread) {
            try {
                wait0(timeoutMillis);
            } catch (InterruptedException e) {
                // virtual thread's interrupt status needs to be cleared
                vthread.getAndClearInterrupt();     // 虚拟线程的中断位存在 VirtualThread 对象上，native 层清不到，Java 层补清后再抛
                throw e;
            }
        } else {
            wait0(timeoutMillis);
        }
    }

    // final modifier so method not in vtable
    private final native void wait0(long timeoutMillis) throws InterruptedException;

    public final void wait(long timeoutMillis, int nanos) throws InterruptedException {
        if (timeoutMillis < 0) {
            throw new IllegalArgumentException("timeoutMillis value is negative");
        }

        if (nanos < 0 || nanos > 999999) {
            throw new IllegalArgumentException(
                                "nanosecond timeout value out of range");
        }

        if (nanos > 0 && timeoutMillis < Long.MAX_VALUE) {
            timeoutMillis++;        // "纳秒精度"是假的：nanos 只要 > 0 就把毫秒向上取整 +1，然后被丢弃
        }

        wait(timeoutMillis);
    }

synchronized (lock) {
    while (!conditionMet()) {   // 用 while 不用 if：应对虚假唤醒 + 唤醒后条件可能又被别人消费掉
        lock.wait();            // 释放锁并挂起，被唤醒后重新拿锁、回到 while 再查一遍
    }
    // 走到这里才真正满足条件
}

@Override
public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;
    User user = (User) o;
    return age == user.age && Objects.equals(name, user.name);
}
@Override
public int hashCode() {
    return Objects.hash(name, age);   // 参与 equals 的字段，就要参与 hashCode
}