Object类源码解析

Object类是一个特殊的类，是所有类的父类，如果一个类没有用extends明确指出继承于某个类，那么它默认继承Object类。这里总结Object类中的几个方法：wait(),notify(),notifyAll(),wait(long timeout), hashCode()和equals()。

1.wait()

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

wait()方法就是使线程停止运行。

1. 方法wait()的作用是使当前执行代码的线程进行等待，该方法是用来将当前线程置入“预执行队列”中，并且在wait()所在的代码处停止执行，直到接到通知或被中断为止。
2. wait()方法只能在同步方法中或同步块中调用。如果调用wait()时，没有持有适当的锁，会抛出异常。
3. wait()方法执行后，当前线程释放锁，线程与其它线程竞争重新获取锁。

观察一下wait()方法的使用:

public static void main(String[] args) throws InterruptedException {
Object object = new Object();
synchronized (object) {
System.out.println("等待中...");
object.wait();
System.out.println("等待已过...");
}
System.out.println("main方法结束...");
}

这样在执行到object.wait()之后就一直等待下去，那么程序肯定不能一直这么等待下去了。这个时候就需要使用到了另外一个方法唤醒的方法notify()。

2.notify()

public final native void notify();

notify方法就是使停止的线程继续运行。

1. 方法notify()也要在同步方法或同步块中调用，该方法是用来通知那些可能等待该对象的对象锁的其它线程，对其发出通知notify，并使它们重新获取该对象的对象锁。如果有多个线程等待，则有线程规划器随机挑选出一个呈wait状态的线程。
2. 在notify()方法后，当前线程不会马上释放该对象锁，要等到执行notify()方法的线程将程序执行完，也就是退出同步代码块之后才会释放对象锁。

注意：wait，notify必须使用在synchronized同步方法或者代码块内。

3.notifyAll()

public final native void notifyAll();

notify方法只是唤醒某一个等待线程，notifyAll方法可以一次唤醒所有的等待线程.

4.wait(long timeout)

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

wait(long timeout) 方法的作用和wait()类似，但是增加了一个超时的设置，如果等待时间超过了timeout设定的毫秒数，那么当前线程会继续执行

总结:

1. wait() 方法用来控制当前线程停止执行，等待其他线程对此Object实例调用notify或者notifyAll方法之后再继续执行 .

2. wait(long timeout) 此方法的作用和wait()类似，但是增加了一个超时的设置，如果等待时间超过了timeout设定的毫秒数，那么当前线程会继续执行

3. notify()方法从所有wait线程中选择一个线程，让它开始执行

4. notifyAll()方法通知所有等待此对象的线程，开始执行

如果线程调用了对象的 wait()方法，那么线程便会处于该对象的等待池中，等待池中的线程不会去竞争该对象的锁。
当有线程调用了对象的 notifyAll()方法（唤醒所有 wait 线程）或 notify()方法（只随机唤醒一个 wait 线程），被唤醒的的线程便会进入该对象的锁池中，锁池中的线程会去竞争该对象锁。
优先级高的线程竞争到对象锁的概率大，假若某线程没有竞争到该对象锁，它还会留在锁池中，唯有线程再次调用wait()方法，它才会重新回到等待池中。而竞争到对象锁的线程则继续往下执行，直到执行完了 synchronized 代码块，它会释放掉该对象锁，这时锁池中的线程会继续竞争该对象锁。

5.hashCode()

public native int hashCode();

hashCode的存在主要是为了查找的快捷性，hashCode是用来在散列存储结构中确定对象的存储地址的(后半句说的用hashCode来代表对象就是在hash表中的位置)
为什么hashCode就查找的更快，比如：我们有一个能存放1000个数这样大的内存中，在其中要存放1000个不一样的数字，用最笨的方法，就是存一个数字，就遍历一遍，看有没有相同得数，当存了900个数字，开始存901个数字的时候，就需要跟900个数字进行对比，这样就很麻烦，很是消耗时间，用hashCode来记录对象的位置，来看一下。hash表中有1、2、3、4、5、6、7、8个位置，存第一个数，hashCode为1，该数就放在hash表中1的位置，存到100个数字，hash表中8个位置会有很多数字了，1中可能有20个数字，存101个数字时，它先查hashCode值对应的位置，假设为1，那么就有20个数字和他的hashCode相同，它只需要跟这20个数字相比较(equals)，如果每一个相同，那么就放在1这个位置，这样比较的次数就少了很多，实际上hash表中有很多位置，这里只是举例只有8个，所以比较的次数会让你觉得也挺多的，实际上，如果hash表很大，那么比较的次数就很少很少了。

6.equals()**

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

很明显，该方法就是用来判断两个对象是否是同一个对象. 其底层是使用了“==”来实现，也就是说通过比较两个对象的内存地址是否相同判断是否是同一个对象。

equals()和hashCode()有什么关系呢?

举个栗子: 有n个桶(桶相当于hash表中划分的区域),每个桶中存放了很多对象,对象1通过hash计算放到了其中一个桶中,那么当对象2通过hash计算也放到这个桶中时,怎么识别桶中对象是否和它一样呢?

1.equals()相等的两个对象他们的hashCode()肯定相等，也就是用equals()对比是绝对可靠的。
2.hashCode()相等的两个对象他们的equals()不一定相等，也就是hashCode()不是绝对可靠的。
所有对于需要大量并且快速的对比的话如果都用equals()去做显然效率太低，所以解决方式是，每当需要对比的时候，首先用hashCode()去对比，如果hashCode()不一样，则表示这两个对象肯定不相等（也就是不必再用equals()去再对比了）,如果hashCode()相同，此时再对比他们的equals()，如果equals()也相同，则表示这两个对象是真的相同了，这样既能大大提高了效率也保证了对比的绝对正确性！

为什么重写了equals(),一定要重写hashCode()呢?

hashCode是用于散列数据的快速存取，如利用HashSet/HashMap/Hashtable类来存储数据时，都是根据存储对象的hashcode值来进行判断是否相同的. 这样如果我们对一个对象重写了euqals，意思是只要对象的成员变量值都相等那么euqals就等于true，但不重写hashCode，那么我们再new一个新的对象,当原对象.equals（新对象）等于true时，两者的hashCode却是不一样的，由此将产生了理解的不一致，如在存储散列集合时（如Set类),将会存储了两个值一样的对象,导致混淆，因此，就也需要重写hashCode()
(换个理解)如果仅仅重写了equals()，而没有重写hashCode()方法，会出现什么情况？
字段属性值完全相同的两个对象因为hashCode不同，所以在hashmap中的table数组的下标不同，从而这两个对象就会同时存在于集合中.(当然用不到哈希表的话，其实仅仅重写equals()方法也可以,官方建议重写equals(),一定要重写hashCode()).