java.lang.Object类源码阅读

java.lang.Object类

写在前面：刚刚开始学者看源码，只是个人一些很浅显的理解，后续会不断更新。
Object类是所有类的父类，源码中并没有很多内容，很多方法都是调用的底层c/c++函数，因此主要阅读注释。

1.registerNatives()

/**
     * static 类方法
     * native 调用c/c++的函数
     */
    private static native void registerNatives(); //为自己的类注册本地函数，从而让jvm可以找到类
    static {
        registerNatives();
    }

该方法主要为自己的类注册一个本地函数，从而使jvm可以找到类。

2.Object()

/**
     * Constructs a new object.
     */
    @HotSpotIntrinsicCandidate
    public Object() {}  //空构

一个空构造函数

3.getClass()

/**
     * 得到当前运行对象的类
     * final 无法被重写
     * native  调用c/c++的函数
     * @return
     */
    @HotSpotIntrinsicCandidate
    public final native Class<?> getClass();

返回当前对象的类，返回的对象是当前被同步锁锁定的对象

4.hashCode()

/**
     * 返回对象的hashcode
     * native   调用c/c++函数
     * @return
     */
    @HotSpotIntrinsicCandidate
    public native int hashCode();

返回对象的hashcode，需要被重写

5.equals(Object obj)

/**
     * 用于比较两个对象地址是否相同
     * 若重写了equals方法，通常需要重写hashCode方法
     * @param obj
     * @return
     */
    public boolean equals(Object obj) {
        return (this == obj);
    }

比较两个对象地址是否相等，建议在自己的类中重写，重写时需要满足自反性、对称性、传递性和一致性

6.clone()

/**
     * 返回一个克隆的对象
     * 必须实现Cloneable接口，否则会抛出异常
     * native  调用c/c++函数
     * @return
     * @throws CloneNotSupportedException
     */
    @HotSpotIntrinsicCandidate
    protected native Object clone() throws CloneNotSupportedException;

创建并返回一个对象的副本

7. toString()

/**
     * 返回类名@十六进制字符
     * 建议每个子类重写该方法
     * @return
     */
    public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }

建议每个子类重写该方法，实现自己的toString

8.notify()

/**
     * 随机唤醒一个被阻塞的线程
     * final 类方法
     * native 调用c/c++方法
     */
    @HotSpotIntrinsicCandidate
    public final native void notify();

随机唤醒一个被阻塞的线程，使其进入就绪状态

9.notifyAll()

/**
     * 唤醒所有被阻塞的线程
     * final 类方法
     * native 调用c/c++方法
     */
    @HotSpotIntrinsicCandidate
    public final native void notifyAll();

唤醒所有被阻塞的线程，使其进入就绪状态

10.wait()

/**
     * 阻塞当前线程直到其被唤醒
     * finall 类方法
     * 调用了wait（long）方法
     * @throws InterruptedException
     */
    public final void wait() throws InterruptedException {
        wait(0L);
    }

阻塞当前线程

11.wait(long)

/**
     * 阻塞当前线程至其被唤醒或者达到阻塞时间
     * final 类方法
     * native 调用c/c++方法
     * @param timeoutMillis  阻塞时长
     * @throws InterruptedException
     */
    public final native void wait(long timeoutMillis) throws InterruptedException;

阻塞当前线程，但是会有一个阻塞时间

12.wait(long,int)

/**
     * 阻塞当前线程直到时间结束
     * final 类方法
     * @param timeoutMillis 最大阻塞时间，单位毫秒
     * @param nanos 额外时间，单位纳秒
     * @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++;
        }

        wait(timeoutMillis);
    }

阻塞当前线程，但是可以动态增加阻塞时间

13.finalize()

/**
     * 空方法
     * 子类可以重写，用来释放长期不被引用的对象，即垃圾回收
     * @throws Throwable
     */
    @Deprecated(since="9")
    protected void finalize() throws Throwable { }

垃圾回收机制