摘要：注釋指出方法返回散列值。直到其他線程調(diào)用此對象的方法或方法，當(dāng)前線程被喚醒進入就緒狀態(tài)?？偝瑫r時間以納秒為單位計算為。以上注釋主要就是描述了，和方法的使用規(guī)范。主要的區(qū)別在于在釋放同時，釋放了對象鎖的控制。

Java 是一門面向?qū)ο蟮恼Z言，在 Java 里面一切都可以看作是一個對象，而 Java 里面所有的對象都默認繼承于 Object 類，所以狗哥今天就復(fù)習(xí)了一遍這個類。

上圖看出 Object 一共有 12 個方法，其中 registerNatives() 是由 C 語言實現(xiàn)的，這個不在研究范圍內(nèi)。

/**
     * Returns the runtime class of this {@code Object}. The returned
     * {@code Class} object is the object that is locked by {@code
     * static synchronized} methods of the represented class.
*/
public final native Class getClass();

這個方法的作用就是返回某個對象的運行時類，它的返回值是 Class 類型，Class c = obj.getClass()；通過對象 c ，我們可以獲取該對象的所有成員方法，每個成員方法都是一個 Method 對象；我們也可以獲取該對象的所有成員變量，每個成員變量都是一個 Field 對象；同樣的，我們也可以獲取該對象的構(gòu)造函數(shù)，構(gòu)造函數(shù)則是一個 Constructor 對象。這個方法在反射時會常用到。

/**
     * Returns a hash code value for the object. This method is
     * supported for the benefit of hash tables such as those provided by
     * {@link java.util.HashMap}.
*/
    public native int hashCode();

這個方法的注釋比較長，就不放出來了。注釋指出：

hashCode 方法返回散列值。

返回值默認是由對象的地址轉(zhuǎn)換而來的。

同一個對象調(diào)用 hashCode 的返回值是相等的。

兩個對象的 equals 相等，那 hashCode 一定相等。

兩個對象的 equals 不相等，那 hashCode 也不一定相等。

public boolean equals(Object obj) {
    return (this == obj);
}

equals 的實現(xiàn)非常簡單，它的作用就是比較兩個對象是否相等，而比較的依據(jù)就是二者的內(nèi)存地址。除此之外，equals 還遵循以下幾個原則：

1、自反性：x.equals(x);  // true
2、對稱性：x.equals(y) == y.equals(x);  // true
3、傳遞性：if (x.equals(y) && y.equals(z))
            x.equals(z); // true;

4、一致性，只要對象沒有被修改，多次調(diào)用 equals() 方法結(jié)果不變：
x.equals(y) == x.equals(y); // true 

5、非空性，對任何不是 null 的對象 x 調(diào)用 x.equals(null) 結(jié)果都為 false ：
x.equals(null); // false;

為什么要重寫 hashcode 和 equals ？

這個問題之前分享過舊文：https://mp.weixin.qq.com/s/iI...

protected native Object clone() throws CloneNotSupportedException;

clone() 是 Object 的 protected 方法，它不是 public，一個類不顯式去重寫 clone()，其它類就不能直接去調(diào)用該類實例的 clone() 方法。此外，Clone 的注釋中還提到比較重要的幾點：

克隆的對象必須要實現(xiàn) Cloneable 接口并重寫 clone 方法，否則會報 CloneNotSupportedException 異常

clone() 方法并不是 Cloneable 接口的方法，而是 Object 的一個 protected 方法。Cloneable 接口只是規(guī)定，如果一個類沒有實現(xiàn) Cloneable 接口又調(diào)用了 clone() 方法，就會拋出 CloneNotSupportedException。

淺拷貝：拷貝對象和原始對象的引用類型引用同一個對象。

深拷貝：拷貝對象和原始對象的引用類型引用不同對象。

關(guān)于淺拷貝與深拷貝的詳解，請看這篇舊文：
https://mp.weixin.qq.com/s/I6...

public String toString() {
       return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

這個方法應(yīng)該沒什么好講的，原生的 toString 方法僅僅返回，對象名 + 它的 hashCode ，但做過開發(fā)的都知道，原生的 toString 作用不大。我們需要重寫 toString 一般是因為方便調(diào)試，需要知道對象的屬性值，而不僅僅是 hashCode 。所以，應(yīng)該像下面這樣重寫：

public class Student {

    private int age;

    private String name;

    // 省略 get、set

    @Override
    public String toString() {
        return "Student{" +
                "age=" + age +
                ", name="" + name + """ +
                "}";
    }
}

public final native void notify();
public final native void notifyAll();

首先是 notify ，注釋就不貼出來了，notify 的作用就是隨機喚醒在等待隊列的某個線程，而 notifyAll 就是喚醒在等待隊列的所有線程。

public final void wait() throws InterruptedException {
     wait(0);
}

public final native void wait(long timeout) throws InterruptedException;

public final void wait(long timeout, int nanos) throws InterruptedException {
        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);
}

然后是 wait ，wait 的作用是讓當(dāng)前線程進入等待狀態(tài)，同時，wait() 也會讓當(dāng)前線程釋放它所持有的鎖。直到其他線程調(diào)用此對象的 notify() 方法或 notifyAll() 方法，當(dāng)前線程被喚醒進入就緒狀態(tài)。

wait(long timeout) （以毫秒為單位）讓當(dāng)前線程處于等待(阻塞)狀態(tài)，直到其他線程調(diào)用此對象的notify() 方法或 notifyAll() 方法，或者超過指定的時間量，當(dāng)前線程被喚醒進入就緒狀態(tài)。

wait(long timeout, int nanos) 和 wait(long timeout) 功能一樣，唯一的區(qū)別是這個可以提供更高的精度。總超時時間（以納秒為單位）計算為 1000000 *timeout+ nanos。By the way ，wait(0,0) 和 wait(0) 效果一樣。

除此之外，notify 和 wait 的注釋中還有這么一段：

* 

     * This method should only be called by a thread that is the owner
     * of this object"s monitor. A thread becomes the owner of the
     * object"s monitor in one of three ways:
     * 

     * 
By executing a synchronized instance method of that object.
     * 
By executing the body of a {@code synchronized} statement
     *     that synchronizes on the object.
     * 
For objects of type {@code Class,} by executing a
     *     synchronized static method of that class.
     * 
* 

看到這英文，剛過四級的我瑟瑟發(fā)抖。以上注釋主要就是描述了，notify 和 wait 方法的使用規(guī)范。意思就是這二者必須在 synchronized 修飾的同步方法或同步代碼中使用。

為什么 wait() 必須在同步 (Synchronized) 方法/代碼塊中調(diào)用？

答：調(diào)用 wait() 就是釋放鎖，釋放鎖的前提是必須要先獲得鎖，先獲得鎖才能釋放鎖。

為什么 notify()、notifyAll() 必須在同步 (Synchronized) 方法/代碼塊中調(diào)用？

答：notify()、notifyAll() 是將鎖交給含有 wait() 方法的線程，讓其繼續(xù)執(zhí)行下去，如果自身沒有鎖，怎么叫把鎖交給其他線程呢？（本質(zhì)是讓處于入口隊列的線程競爭鎖）

詳細解釋請參考這篇博文：https://blog.csdn.net/qq_42145871/article/details/81950949

Thread.sleep() 和 Object.wait() 有什么區(qū)別？

首先，二者都可以暫停當(dāng)前線程，釋放 CPU 控制權(quán)。主要的區(qū)別在于 Object.wait()在釋放 CPU 同時，釋放了對象鎖的控制。而 Thread.sleep() 沒有對鎖釋放。換句話說 sleep 就是耍流氓，占著茅坑不拉屎。

1、java | 什么是動態(tài)代理

2、SpringBoot?| 啟動原理

3、SpringBoot | 自動配置原理