Object 类
Object 类结构
概述
已知所有类的基类——java.lang.Object
- Object 类是所有类的基类，当一个类没有直接继承某个类时，默认继承Object类
- Object 类属于 java.lang 包，此包下的所有类在使用时无需手动导入，系统会在程序编译期间自动导入。
那么， 在编译源代码时，当一个类没有显式标明继承的父类时，编译器会为其指定一个默认的父类（一般为Object），而交给虚拟机处理这个类时，由于这个类已经有一个默认的父类了，因此，VM仍然会按照常规的方法像处理其他类一样来处理这个类。
这里有7个native方法：registerNatives()、getClass()、hashCode()、clone()、notify()、notifyAll()、wait(long)
JNI：Java Native Interface：
①、标准的 Java 类库不支持应用程序平台所需的平台相关功能。
②、我们已经用另一种语言编写了一个类库，如何用Java代码调用？
③、某些运行次数特别多的方法代码，为了加快性能，我们需要用更接近硬件的语言（比如汇编）编写。
上面这三种需求，其实说到底就是如何用 Java 代码调用不同语言编写的代码。那么 JNI 应运而生了
native 用来修饰方法，用 native 声明的方法表示告知 JVM 调用，该方法在外部定义，我们可以用任何语言去实现它。 简单地讲，一个native Method就是一个 Java 调用非 Java 代码的接口。
源码解析
package java.lang;
public class Object {
/**
* 一个本地方法,具体是用C(C++)在DLL中实现的,然后通过JNI调用
*/
private static native void registerNatives();
/**
* 对象初始化时自动调用此方法
*/
static {
registerNatives();
}
/**
* 返回此Object的运行时类
*/
public final native Class<?> getClass();
/**
* hashCode的常规协定是：
* 1.在java应用程序执行期间,在对同一对象多次调用hashCode()方法时,必须一致地返回相同的整数,前提是将对象进行equals比较时所用的信息没有被修改。
* 从某一应用程序的一次执行到同一应用程序的另一次执行,该整数无需保持一致。
* 2.如果根据equals(object)方法,两个对象是相等的,那么对这两个对象中的每个对象调用hashCode方法都必须生成相同的整数结果。
* 3.如果根据equals(java.lang.Object)方法,两个对象不相等,那么对这两个对象中的任一对象上调用hashCode()方法不要求一定生成不同的整数结果。
* 但是,应该意识到,为不相等的对象生成不同整数结果可以提高哈希表的性能。
*/
public native int hashCode();
/**
* 这里比较的是对象的内存地址
*/
public boolean equals(Object obj) {
return (this == obj);
}
/**
* 本地clone方法,用于对象的复制
*/
protected native Object clone() throws CloneNotSupportedException;
/**
* 返回该对象的字符串表示,非常重要的方法
* getClass().getName();获取字节码文件的对应全路径名例如java.lang.Object
* Integer.toHexString(hashCode());将哈希值转成16进制数格式的字符串。
*/
public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
/**
* 不能被重写，用于唤醒一个在因等待该对象（调用了wait方法）被处于等待状态（waiting 或 time_wait）的线程，该方法只能同步 * 方法或同步块中调用
*/
public final native void notify();
/**
* 不能被重写，用于唤醒所有在因等待该对象（调用wait方法）被处于等待状态（waiting或time_waiting）的线程，该方法只能同步方 * 法或同步块中调用
*/
public final native void notifyAll();
/**
* 不能被重写，用于在线程调用中，导致当前线程进入等待状态（time_waiting)，timeout单位为毫秒,该方法只能同步方法或同步块中 * 调用,超过设置时间后线程重新进入可运行状态
*/
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);
}
/**
* 在其他线程调用此对象的notify()方法或notifyAll()方法前,导致当前线程等待。换句话说,此方法的行为就好像它仅执行wait(0)调 用一样。
* 当前线程必须拥有此对象监视器。
* 该线程发布对此监视器的所有权并等待,直到其他线程通过调用notify方法或notifyAll方法通知在此对象的监视器上等待的线程醒来,
* 然后该线程将等到重新获得对监视器的所有权后才能继续执行。
*/
public final void wait() throws InterruptedException {
wait(0);
}
/**
* 这个方法用于当对象被回收时调用，这个由JVM支持，Object的finalize方法默认是什么都没有做，如果子类需要在对象被回收时执行 一些逻辑处理，则可以重写finalize方法。
*/
protected void finalize() throws Throwable {
}
}
类构造器
一个类必须要有一个构造器的存在，如果没有显示声明，那么系统会默认创造一个无参构造器，在JDK的Object类源码中，是看不到构造器的，系统会自动添加一个无参构造器。我们可以通过：
// 构造一个Object类的对象。
Object obj = new Object()；
equals 方法
源码
- Object 类中的equals 方法：
public boolean equals(Object obj) {
return (this == obj);
}
结论：
- 在 Object 类中，== 运算符和 equals 方法是等价的，都是比较两个对象的引用是否相等，从另一方面来讲，如果两个对象的引用相等，那么这两个对象一定是相等的
- 对于我们自定义的一个对象，如果不重写 equals 方法，那么在比较对象的时候就是调用 Object 类的 equals 方法，也就是用 == 运算符比较两个对象
String 类重写 equals 方法
public boolean equals(Object anObject) {
//如果内存地址相等，那必须equal
if (this == anObject) {
return true;
}
//如果对象是String类型
if (anObject instanceof String) {
String anotherString = (String)anObject;
// 获取调用方的字符串长度赋值给n
int n = value.length;
//判断长度相等
if (n == anotherString.value.length) {
char v1[] = value;
char v2[] = anotherString.value;
int i = 0;
//那我们就逐个字符的比较
while (n-- != 0) {
//从前往后，任意一个字符不匹配，直接返回false
if (v1[i] != v2[i])
return false;
i++;
}
//全部匹配结束，返回true
return true;
}
}
return false;
}
String 是引用类型，比较时不能比较引用是否相等，重点是字符串的内容是否相等。
所以 String 类定义两个对象相等的标准是字符串内容都相同。
在Java规范中，对 equals 方法的使用必须遵循以下几个原则：
- 自反性：对于任何非空引用值 x，x.equals(x) 都应返回 true。
- 对称性：对于任何非空引用值 x 和 y，当且仅当 y.equals(x) 返回 true 时，x.equals(y) 才应返回 true。
- 传递性：对于任何非空引用值 x、y 和 z，如果 x.equals(y) 返回 true，并且 y.equals(z) 返回 true，那么 x.equals(z) 应返回 true。
- 一致性：对于任何非空引用值 x 和 y，多次调用 x.equals(y) 始终返回 true 或始终返回 false，前提是对象上 equals 比较中所用的信息没有被修改
- 对于任何非空引用值 x，x.equals(null) 都应返回 false。
重写 equals 原则
定义一个 Person 类，然后重写其equals 方法，比较两个 Person 对象：
public class Person {
private String pname;
private int page;
public Person(){}
public Person(String pname,int page){
this.pname = pname;
this.page = page;
}
public int getPage() {
return page;
}
public void setPage(int page) {
this.page = page;
}
public String getPname() {
return pname;
}
public void setPname(String pname) {
this.pname = pname;
}
@Override
public boolean equals(Object obj) {
if(this == obj){//引用相等那么两个对象当然相等
return true;
}
/*if(obj == null || !(obj instanceof Person)){//对象为空或者不是Person类的实例
return false;
}*/
if(obj == null || (getClass() != obj.getClass())){//对象为空或者不是Person类的实例
return false;
}
Person otherPerson = (Person)obj;
if(otherPerson.getPname().equals(this.getPname()) && otherPerson.getPage()==this.getPage()){
return true;
}
return false;
}
public static void main(String[] args) {
Person p1 = new Person("Tom",21);
Person p2 = new Person("Marry",20);
System.out.println(p1==p2);//false
System.out.println(p1.equals(p2));//false
Person p3 = new Person("Tom",21);
System.out.println(p1.equals(p3));//true
}
}
通过重写 equals 方法，我们自定义两个对象相等的标尺为Person对象的两个属性都相等，则对象相等，否则不相等。
如果不重写 equals 方法，那么始终是调用 Object 类的equals 方法，也就是用 == 比较两个对象在栈内存中的引用地址是否相等。
重写equals方法总结建议：
@Override
public boolean equals(Object otherObject) {
//1、判断比较的两个对象引用是否相等，如果引用相等那么表示是同一个对象，那么当然相等
if(this == otherObject){
return true;
}
//2、如果 otherObject 为 null，直接返回false，表示不相等
if(otherObject == null ){//对象为空或者不是Person类的实例
return false;
}
//3、比较 this 和 otherObject 是否是同一个类（注意下面两个只能使用一种）
//3.1：如果 equals 的语义在每个子类中所有改变，就使用 getClass 检测
if(this.getClass() != otherObject.getClass()){
return false;
}
//3.2：如果所有的子类都有统一的定义，那么使用 instanceof 检测
if(!(otherObject instanceof Person)){
return false;
}
//4、将 otherObject 转换成对应的类类型变量
Person other = (Person) otherObject;
//5、最后对对象的属性进行比较。使用 == 比较基本类型，使用 equals 比较对象。如果都相等则返回true，否则返回false
// 使用 Objects 工具类的 equals 方法防止比较的两个对象有一个为 null而报错，因为 null.equals() 是会抛异常的
return Objects.equals(this.pname,other.pname) && this.page == other.page;
//6、注意如果是在子类中定义equals，则要包含 super.equals(other)
//return super.equals(other) && Objects.equals(this.pname,other.pname) && this.page == other.page;
}
注意，无论何时重写此方法，通常都必须重写hashCode方法，以维护hashCode方法的一般约定，该方法声明相等对象必须具有相同的哈希代码
hashCode 方法
hashCode 作用
前面我们说过判断一个元素是否相等可以通过 equals 方法，没增加一个元素，那么我们就通过 equals 方法判断集合中的每一个元素是否重复，但是如果集合中有10000个元素了，但我们新加入一个元素时，那就需要进行10000次equals方法的调用，这显然效率很低。
hashCode 由哈希算法（散列算法）生成，是将数据依特定算法产生的结果直接指定到一个地址上。
当集合要添加新的元素时，先调用这个元素的 hashCode 方法，定位到它应该放置的物理位置上：
- 如果这个位置上没有元素，它就可以直接存储在这个位置上，不用再进行任何比较了
- 如果这个位置上已经有元素了，就调用它的equals方法与新元素进行比较，相同的话就不存了
- 不相同的话，也就是发生了Hash key相同导致冲突的情况，那么就在这个Hash key的地方产生一个链表，将所有产生相同HashCode的对象放到这个单链表
对象内存布局
当一个对象在堆内存中分配好并且初始化完成之后的结构如下：
- 添加对齐填充是为了保证对象的总大小是8的整数倍个字节
- 类型指针占4个字节是因为默认开启了指针压缩，如果不开启指针压缩，则占8个字节
hashCode 的值存在Java对象头里的，Hotspot虚拟机的对象头主要包括两部分数据：
- Mark Word（标记字段）：对象指向它的类元数据的指针，虚拟机通过这个指针来确定这个对象是哪个类的实例
- Class Pointer（类型指针）：用于存储对象自身的运行时数据，它是实现轻量级锁和偏向锁的关键
对象头结构如下：
源码解析
源码 Object 类中定义如下：
// 是一个用 native 声明的本地方法，作用是返回对象的散列码，是 int 类型的数值。
public native int hashCode();
- HashCode的存在主要是为了查找的快捷性
- HashCode是用来在散列存储结构中确定对象的存储地址
查看：src\share\native\java\lang\Object.c
JNIEXPORT void JNICALL//jni调用
//全路径：java_lang_Object_registerNatives是java对应的包下方法
Java_java_lang_Object_registerNatives(JNIEnv *env, jclass cls)
{
//jni环境调用；下面的参数methods对应的java方法
(*env)->RegisterNatives(env, cls,
methods, sizeof(methods)/sizeof(methods[0]));
}
对应方法：
static JNINativeMethod methods[] = {
//JAVA方法 返回值 （参数） c++函数
{"hashCode", "()I", (void *)&JVM_IHashCode},
{"wait", "(J)V", (void *)&JVM_MonitorWait},
{"notify", "()V", (void *)&JVM_MonitorNotify},
{"notifyAll", "()V", (void *)&JVM_MonitorNotifyAll},
{"clone", "()Ljava/lang/Object;", (void *)&JVM_Clone},
};
调用 src\share\vm\prims\jvm.cpp JVM_IHashCod 方法：
/*
JVM_ENTRY is a preprocessor macro that
adds some boilerplate code that is common for all functions of HotSpot JVM API.
This API is a connection layer between the native code of JDK class library and the JVM.
JVM_ENTRY是一个预加载宏，增加一些样板代码到jvm的所有function中
这个api是位于本地方法与jdk之间的一个连接层。
所以，此处才是生成hashCode的逻辑！
*/
JVM_ENTRY(jint, JVM_IHashCode(JNIEnv* env, jobject handle))
JVMWrapper("JVM_IHashCode");
//调用了ObjectSynchronizer对象的FastHashCode
return handle == NULL ? 0 : ObjectSynchronizer::FastHashCode (THREAD, JNIHandles::resolve_non_null(handle)) ;
JVM_END
调用 src/hotspot/share/runtime/synchronizer.cpp 内部的 ObjectSynchronizer::FastHashCode：
intptr_t ObjectSynchronizer::FastHashCode (Thread * Self, oop obj) {
//是否开启了偏向锁(Biased：偏向，倾向)
if (UseBiasedLocking) {
//如果当前对象处于偏向锁状态
if (obj->mark()->has_bias_pattern()) {
Handle hobj (Self, obj) ;
assert (Universe::verify_in_progress() ||
!SafepointSynchronize::is_at_safepoint(),
"biases should not be seen by VM thread here");
//那么就撤销偏向锁（达到无锁状态，revoke：废除）
BiasedLocking::revoke_and_rebias(hobj, false, JavaThread::current());
obj = hobj() ;
//断言下，看看是否撤销成功（撤销后为无锁状态）
assert(!obj->mark()->has_bias_pattern(), "biases should be revoked by now");
}
}
// ……
ObjectMonitor* monitor = NULL;
markOop temp, test;
intptr_t hash;
//读出一个稳定的mark;防止对象obj处于膨胀状态；
//如果正在膨胀，就等他膨胀完毕再读出来
markOop mark = ReadStableMark (obj);
//是否撤销了偏向锁（也就是无锁状态）（neutral：中立，不偏不斜的）
if (mark->is_neutral()) {
//从mark头上取hash值
hash = mark->hash();
//如果有，直接返回这个hashcode（xor）
if (hash) { // if it has hash, just return it
return hash;
}
//如果没有就新生成一个(get_next_hash)
hash = get_next_hash(Self, obj); // allocate a new hash code
//生成后，原子性设置，将hash放在对象头里去，这样下次就可以直接取了
temp = mark->copy_set_hash(hash); // merge the hash code into header
// use (machine word version) atomic operation to install the hash
test = (markOop) Atomic::cmpxchg_ptr(temp, obj->mark_addr(), mark);
if (test == mark) {
return hash;
}
// If atomic operation failed, we must inflate the header
// into heavy weight monitor. We could add more code here
// for fast path, but it does not worth the complexity.
//如果已经升级成了重量级锁，那么找到它的monitor
//也就是我们所说的内置锁(objectMonitor)，这是c里的数据类型
//因为锁升级后，mark里的bit位已经不再存储hashcode，而是指向monitor的地址
//而升级的markword呢？被移到了c的monitor里
} else if (mark->has_monitor()) {
//沿着monitor找header，也就是对象头
monitor = mark->monitor();
temp = monitor->header();
assert (temp->is_neutral(), "invariant") ;
//找到header后取hash返回
hash = temp->hash();
if (hash) {
return hash;
}
// Skip to the following code to reduce code size
} else if (Self->is_lock_owned((address)mark->locker())) {
//轻量级锁的话，也是从java对象头移到了c里，叫helper
temp = mark->displaced_mark_helper(); // this is a lightweight monitor owned
assert (temp->is_neutral(), "invariant") ;
hash = temp->hash(); // by current thread, check if the displaced
//找到，返回
if (hash) { // header contains hash code
return hash;
}
}
总结：
通过分析虚拟机源码我们证明了hashCode不是直接用的内存地址，而是采取一定的算法来生成，hashcode值的存储在mark word里，与锁共用一段bit位，这就造成了跟锁状态相关性：
- 如果是无锁态：调用 hashcode 方法侯，hashcode 存储在该对象的对象头中
-
如果是偏向锁：一旦调用hashcode，偏向锁将被撤销，hashcode被保存占位mark word，对象被打回无锁状态
-
如果无法撤销偏向锁：对象再也回不到偏向锁状态而是升级为重量级锁hash code跟随mark word被移动到c的object monitor，从那里取
getClass 方法
getClass()在 Object 类中如下，作用是返回对象的运行时类。
public final native Class<?> getClass();
这是一个用 native 关键字修饰的方法
native 用来修饰方法，用 native 声明的方法表示告知 JVM 调用，该方法在外部定义，我们可以用任何语言去实现它。
简单地讲，一个native Method就是一个 Java 调用非 Java 代码的接口。
这里我们要知道用 native 修饰的方法我们不用考虑，由操作系统帮我们实现，该方法的作用是返回一个对象的运行时类，通过这个类对象我们可以获取该运行时类的相关属性和方法
toString 方法
public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
- getClass().getName()是返回对象的全类名（包含包名）,Integer.toHexString(hashCode()) 是以16进制无符号整数形式返回此哈希码的字符串表示形式。
- 打印某个对象时，默认是调用 toString 方法，比如 System.out.println(person),等价于 System.out.println(person.toString())
clone方法
/**
* 本地clone方法,用于对象的复制
*/
protected native Object clone() throws CloneNotSupportedException;
保护方法，实现对象的浅拷贝，只有实现了Cloneable接口才可以调用该方法，否则抛出CloneNotSupportedException异常。
finalize 方法
protected void finalize() throws Throwable { }
当 GC 确定不再有对该对象的引用时，GC 会调用对象的 finalize() 方法来清除回收。
Java VM 会确保一个对象的 finalize() 方法只被调用一次，而且程序中不能直接调用 finalize() 方法。
finalize() 方法通常也不可预测，而且很危险，一般情况下，不必要覆盖 finalize() 方法。
registerNatives 方法
private static native void registerNatives();
这是一个本地方法，我们要知道一个类定义了本地方法后，想要调用操作系统的实现，必须还要装载本地库
static {
registerNatives();
}
静态代码块就是一个类在初始化过程中必定会执行的内容，所以在类加载的时候是会执行该方法的，通过该方法来注册本地方法。
