Object 源码阅读

Object 源码阅读

/**
 *  Object 类是类继承结构的根类，每一个类型都以 Object 作为其父类，包括数组。
 */
public class Object {

    private static native void registerNatives();
    static {
        registerNatives();
    }

    /**
     *  创建一个新的对象
     */
    @HotSpotIntrinsicCandidate
    public Object() {}

    /**
     *  返回此对象的目标 Class 对象
     */
    @Override
    @HotSpotIntrinsicCandidate
    public final native Class<?> getClass();

    /**
     *  返回此对象的哈希值
     *  如果两个对象的 equals(Object) 方法返回 true，则它们的哈希值必须相等。
     */
    @Override
    @HotSpotIntrinsicCandidate
    public native int hashCode();

    /**
     *  此对象是否和目标对象 obj 相等
     * 1）反射性：对于任何非空引用 x，x.equals(x) 应该返回 true。
     * 2）对称性：对于任何非空引用 x、y，如果 x.equals(y) 返回 true，则 y.equals(x) 也应该返回 true。
     * 3）传递性：对于任何非空引用 x、y、z，如果 x.equals(y) 和 y.equals(z) 返回 true，则 x.equals(z) 也应该返回 true。
     * 4）一致性：对于任何非空引用 x、y，则多次调用 x.equals(y) 应该一致地返回 true 或 false。
     * 5）对于任何非空引用，x.equals(null) 应该返回 false。
     *  如果重写了 equals 方法，则必须重写 hashcode 方法。
     */
    public boolean equals(Object obj) {
        return this == obj;
    }

    /**
     *  克隆此对象
     *
     * 1）x.clone() != x 应该返回 true
     * 2）x.clone().getClass() == x.getClass() 应该返回 true
     * 3）x.clone().equals(x) 应该返回 true
     */
    @Override
    @HotSpotIntrinsicCandidate
    protected native Object clone() throws CloneNotSupportedException;

    /**
     *  返回此对象的字符串表示。
     *  默认值 getClass().getName() + '@' + Integer.toHexString(hashCode())
     */
    @Override
    public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }

    /**
     *  随机唤醒一个在此对象监视器上阻塞等待的线程。
     *  1）只有当目标线程放弃此对象的监视器时，被唤醒的线程才能正常执行。
     *  2）此方法调用之前，目标线程必须先获得此对象的监视器，
     *      调用此对象的同步方法
     *      通过 synchronized(obj){} 同步代码块获取此对象的监视器
     *      如果是 Class 类型，则可以调用此类型的静态同步方法
     *  3）任何时刻，只能有一个线程拥有此对象的监视器
     */
    @Override
    @HotSpotIntrinsicCandidate
    public final native void notify();

    /**
     *  唤醒所有在此对象的监视器上阻塞等待的线程
     *  1）只有当目标线程放弃此对象的监视器时，被唤醒的线程才能正常执行。
     *  2）此方法调用之前，目标线程必须先获得此对象的监视器，
     *      调用此对象的同步方法
     *      通过 synchronized(obj){} 同步代码块获取此对象的监视器
     *      如果是 Class 类型，则可以调用此类型的静态同步方法
     *  3）任何时刻，只能有一个线程拥有此对象的监视器
     */
    @Override
    @HotSpotIntrinsicCandidate
    public final native void notifyAll();

    /**
     *  让当前线程在此对象的监视器上阻塞等待，直到被唤醒或被中断。
     *  1）此方法调用之前，目标线程必须先获得此对象的监视器，
     *      调用此对象的同步方法
     *      通过 synchronized(obj){} 同步代码块获取此对象的监视器
     *      如果是 Class 类型，则可以调用此类型的静态同步方法
     */
    @Override
    public final void wait() throws InterruptedException {
        wait(0L);
    }

    /**
     *  让当前线程在此对象的监视器上阻塞等待，直到被唤醒、被中断、阻塞等待超时。
     *  1）此方法调用之前，目标线程必须先获得此对象的监视器，
     *      调用此对象的同步方法
     *      通过 synchronized(obj){} 同步代码块获取此对象的监视器
     *      如果是 Class 类型，则可以调用此类型的静态同步方法
     *
     * @param timeout   阻塞等待的毫秒数
     */
    @Override
    public final native void wait(long timeout) throws InterruptedException;

    /**
     *  让当前线程在此对象的监视器上阻塞等待，直到被唤醒、被中断、阻塞等待超时。
     *  1）此方法调用之前，目标线程必须先获得此对象的监视器，
     *      调用此对象的同步方法
     *      通过 synchronized(obj){} 同步代码块获取此对象的监视器
     *      如果是 Class 类型，则可以调用此类型的静态同步方法
     *
     * @param timeout   阻塞等待的毫秒数
     * @param nanos     纳秒增量
     */
    @Override
    public final void wait(long timeout, int nanos) throws InterruptedException {
        // 1）超时时间为负数
        if (timeout < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }

        // 纳秒数非法
        if (nanos < 0 || nanos > 999999) {
            throw new IllegalArgumentException(
                    "nanosecond timeout value out of range");
        }

        // 超时
        if (nanos > 0) {
            timeout++;
        }

        wait(timeout);
    }

    /**
     *  垃圾回收器将调用此方法执行此对象的垃圾回收，
     *  1）调用时机不确定
     *  2）只能调用一次
     *  3）不建议覆盖此方法执行资源释放
     *  4）如果此方法抛出异常，则该异常将被忽略，如果在此方法中执行资源释放，则可能导致资源泄漏
     * <p>
     */
    @Override
    @Deprecated(since="9")
    protected void finalize() throws Throwable { }
}