（转载）【java基础之jdk源码】Object

转自：http://www.cnblogs.com/cq-home/p/6431426.html

最新在整体回归下java基础薄弱环节，以下为自己整理笔记，若有理解错误，请批评指正，谢谢。

java.lang.Object为java所有类的基类，所以一般的类都可用重写或直接使用Object下方法，以下为逻辑结构图，没有画类图

（注： 以上绿色方法为 非native方法  粉色方法为 native方法）

那么问题来了 ：

1、what is a native object? 

　　本人理解： native关键字标识的java方法为本地方法，底层是有c/c++编写的程序编译后dll文件，java加载dll文件后，

　　　　　　　 可用通过本地方法调用dll中函数，如有疑问可用参考JNI使用方式，看参考：http://blog.csdn.net/yangjiali014/article/details/1633017

　　　　　　　　以下为Object类对应openjdk\jdk\src\share\native\java\lang\Object.c的源码片段1：

1 static JNINativeMethod methods[] = {
2     {"hashCode",    "()I",                    (void *)&JVM_IHashCode},
3     {"wait",        "(J)V",                   (void *)&JVM_MonitorWait},
4     {"notify",      "()V",                    (void *)&JVM_MonitorNotify},
5     {"notifyAll",   "()V",                    (void *)&JVM_MonitorNotifyAll},
6     {"clone",       "()Ljava/lang/Object;",   (void *)&JVM_Clone},
7 };

　　网友见解：http://stackoverflow.com/questions/4568972/what-is-a-native-object

2、Why exist native method in Object Class?

　　本人理解：涉及调用系统及考虑性能，使用c++或c实现更佳

　　网友见解：http://stackoverflow.com/questions/10578764/why-are-hashcode-and-getclass-native-methods

　　　　　　　http://stackoverflow.com/questions/27224577/why-is-object-clone-native-in-java

　　

现在按上图逐个方法讲讲理解：

　　1、Object():默认构造函数

　　2、 registerNatives():　用于注册 代码片段1中的本地方法到jvm中

　　java代码 片段2

1  private static native void registerNatives();
2  static {
3      registerNatives();
4  }

　　对应c++代码 片段3

1 JNIEXPORT void JNICALL
2 Java_java_lang_Object_registerNatives(JNIEnv *env, jclass cls)
3 {
4     (*env)->RegisterNatives(env, cls,
5                             methods, sizeof(methods)/sizeof(methods[0]));
6 }

　　3、final getClass():  (不能重写方法)方法说明中已经提示：Returns:The Class object that represents the runtime class of this object.

　　　来个简单例子 片段4

 1 package jdk;
 2 
 3 public class ObjectTest {
 4 
 5     public static void main(String[] args) {
 6         A a = new B();
 7         System.out.println(a.getClass());
 8     }
 9 }
10 
11 class A {
12     static{
13         System.out.println("初始化a");
14     }
15     
16 }
17 
18 class B extends A{
19     static{
20         System.out.println("初始化b");
21     }
22 }

　　输出结果：

　　可以看到getClass返回的为class B 非 A。

 　　4、hashCode():返回一个整数的值依赖于内部表示堆上的对象的指针

　　　　方法说明：This is typically implemented by converting the internal address of the object into an integer, but this implementation technique is not 　　　　　　　　　　required by the Java™ programming language

　　一起看下native方法 位于openjdk\hotspot\src\share\vm\prims\jvm.cpp中 JVM_IHashCode的实现 

1 JVM_ENTRY(jint, JVM_IHashCode(JNIEnv* env, jobject handle))
2   JVMWrapper("JVM_IHashCode");
3   // as implemented in the classic virtual machine; return 0 if object is NULL
4   return handle == NULL ? 0 : ObjectSynchronizer::FastHashCode (THREAD, JNIHandles::resolve_non_null(handle)) ;
5 JVM_END

调用了ObjectSynchronizer::FastHashCode方法，位于openjdk\hotspot\src\share\vm\runtime\synchronizer.cpp中 第530行起

  View Code

　　该方法一般会被子类重写，String方法的hashCode方法代码 片段5

　　计算方法是 s[0]31^(n-1) + s[1]31^(n-2) + … + s[n-1]，其中s[0]表示字符串的第一个字符，n表示字符串长度；

 1  public int hashCode() {
 2         int h = hash;
 3         if (h == 0 && value.length > 0) {
 4             char val[] = value;
 5 
 6             for (int i = 0; i < value.length; i++) {
 7                 h = 31 * h + val[i];
 8             }
 9             hash = h;
10         }
11         return h;
12     }

　　5、equals():返回 2个对象的内存地址是否相等

　　源码 片段6

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

　　该方法一般会被子类重写，String方法的equal方法代码 片段7

 　　先比较String对象内存地址相同，若相同则返回true，否则判断String对象对应字符的内容是否相等，若相等则返回true

 1 public boolean equals(Object anObject) {
 2         if (this == anObject) {
 3             return true;
 4         }
 5         if (anObject instanceof String) {
 6             String anotherString = (String)anObject;
 7             int n = value.length;
 8             if (n == anotherString.value.length) {
 9                 char v1[] = value;
10                 char v2[] = anotherString.value;
11                 int i = 0;
12                 while (n-- != 0) {
13                     if (v1[i] != v2[i])
14                         return false;
15                     i++;
16                 }
17                 return true;
18             }
19         }
20         return false;
21     }

　　6、clone() throws CloneNotSupportedException：返回复制对象

　　　　先看下方法的说明：Note that all arrays are considered to implement the interface Cloneable and that the return type of the clone method of an array 　　　　type T[] is T[] where T is any reference or primitive type

　　　　一起看下native方法 位于openjdk\hotspot\src\share\vm\prims\jvm.cpp中 JVM_Clone的实现  片段8

JVM_ENTRY(jobject, JVM_Clone(JNIEnv* env, jobject handle))
  JVMWrapper("JVM_Clone");
  Handle obj(THREAD, JNIHandles::resolve_non_null(handle));
  const KlassHandle klass (THREAD, obj->klass());
  JvmtiVMObjectAllocEventCollector oam;

#ifdef ASSERT
  // Just checking that the cloneable flag is set correct
  if (obj->is_javaArray()) {
    guarantee(klass->is_cloneable(), "all arrays are cloneable");
  } else {
    guarantee(obj->is_instance(), "should be instanceOop");
    bool cloneable = klass->is_subtype_of(SystemDictionary::Cloneable_klass());
    guarantee(cloneable == klass->is_cloneable(), "incorrect cloneable flag");
  }
#endif

  // Check if class of obj supports the Cloneable interface.
  // All arrays are considered to be cloneable (See JLS 20.1.5)
  if (!klass->is_cloneable()) {
    ResourceMark rm(THREAD);
    THROW_MSG_0(vmSymbols::java_lang_CloneNotSupportedException(), klass->external_name());
  }

  // Make shallow object copy
  const int size = obj->size();
  oop new_obj = NULL;
  if (obj->is_javaArray()) {
    const int length = ((arrayOop)obj())->length();
    new_obj = CollectedHeap::array_allocate(klass, size, length, CHECK_NULL);
  } else {
    new_obj = CollectedHeap::obj_allocate(klass, size, CHECK_NULL);
  }
  // 4839641 (4840070): We must do an oop-atomic copy, because if another thread
  // is modifying a reference field in the clonee, a non-oop-atomic copy might
  // be suspended in the middle of copying the pointer and end up with parts
  // of two different pointers in the field.  Subsequent dereferences will crash.
  // 4846409: an oop-copy of objects with long or double fields or arrays of same
  // won't copy the longs/doubles atomically in 32-bit vm's, so we copy jlongs instead
  // of oops.  We know objects are aligned on a minimum of an jlong boundary.
  // The same is true of StubRoutines::object_copy and the various oop_copy
  // variants, and of the code generated by the inline_native_clone intrinsic.
  assert(MinObjAlignmentInBytes >= BytesPerLong, "objects misaligned");
  Copy::conjoint_jlongs_atomic((jlong*)obj(), (jlong*)new_obj,
                               (size_t)align_object_size(size) / HeapWordsPerLong);
  // Clear the header
  new_obj->init_mark();

  // Store check (mark entire object and let gc sort it out)
  BarrierSet* bs = Universe::heap()->barrier_set();
  assert(bs->has_write_region_opt(), "Barrier set does not have write_region");
  bs->write_region(MemRegion((HeapWord*)new_obj, size));

  // Caution: this involves a java upcall, so the clone should be
  // "gc-robust" by this stage.
  if (klass->has_finalizer()) {
    assert(obj->is_instance(), "should be instanceOop");
    new_obj = instanceKlass::register_finalizer(instanceOop(new_obj), CHECK_NULL);
  }

  return JNIHandles::make_local(env, oop(new_obj));
JVM_END

　　隐含意思：数组类型默认可以直接克隆，而其他对象实现clone需要先实现Cloneable接口，否则抛出CloneNotSupportedException异常

　　问题1：对象的创建有多中方式，类似 new 、getInstance、clone等 clone有什么好处？

　　问题2：对象调用clone方法生成的对象 和 原对象是否还有什么关联关系？

　　问题3 : 对象clone存在 “浅复制”、“深复制”概念，怎么区分？

　　带着这3个问题，理解Object clone方法：

　　　　1、一般native方法比java中非native方法执行效率高 ，看示例  片段9

 1 package jdk;
 2 
 3 import java.util.Calendar;
 4 import java.util.Date;
 5 
 6 public class ObjectCloneTest1 {
 7 
 8     static final int N = 100000;
 9 
10     public static void main(String[] args) {
11 
12         final Date date = new Date();
13 
14         {
15 
16             final long startTime = System.currentTimeMillis();
17             for (int i = 0; i < N; i++) {
18                 Date date2 = (Date) date.clone();
19             }
20 
21             final long endTime = System.currentTimeMillis();
22 
23             System.out.println("clone:" + (endTime - startTime) + "ms");
24         }
25 
26         {
27             final long startTime = System.currentTimeMillis();
28             for (int i = 0; i < N; i++) {
29                 final Calendar cal = Calendar.getInstance();
30                 cal.setTime(date);
31                 final Date date2 = cal.getTime();
32             }
33 
34             final long endTime = System.currentTimeMillis();
35             System.out.println("Calender.setTime:" + (endTime - startTime) + "ms");
36 
37         }
38 
39     }
40 
41 }

　　2、clone生成的新对象与原对象的关系，需要区别2个对象建是否存在相同的引用或对应的内存地址是否存在共用情况，若存在则 该次clone为 “浅复制”，否则为“深复制”, 而且Object的clone方法是属于 “浅复制”，看示例  片段10

  View Code

　　"深复制"时，需要将共同关联的引用也复制完全看示例  片段11

 

  View Code

　　7、toString():a string representation of the object.

　　　　方法说明：

　　　　The toString method for class Object returns a string consisting of the name of the class of which the object is an instance, the at-sign character `@', 　　　　and the unsigned hexadecimal representation of the hash code of the object. In other words, this method returns a string equal to the value of:

 getClass().getName() + '@' + Integer.toHexString(hashCode())

 　　默认返回对象的名称及引用地址，但一般被子类重写用于说明子类相关属性值描述

　　8、final notify() : 不能被重写，用于唤醒一个在因等待该对象（调用了wait方法）被处于等待状态（waiting 或 time_wait）的线程，该方法只能同步方法或同步块中调用

　　　　方法说明：Wakes up a single thread that is waiting on this object's monitor. If any threads are waiting on this object, one of them is chosen to be 　　　　awakened. The choice is arbitrary and occurs at the discretion of the implementation. A thread waits on an object's monitor by calling one of the wait 　　　　methods. 

　　9、final notifyAll():不能被重写，用于唤醒所有在因等待该对象（调用wait方法）被处于等待状态（waiting或time_waiting）的线程，该方法只能同步方法或同步块中调用

　　　　方法说明：Wakes up all threads that are waiting on this object's monitor. A thread waits on an object's monitor by calling one of the waitmethods. 

　　10、final wait(long timeout)：不能被重写，用于在线程调用中，导致当前线程进入等待状态（time_waiting)，timeout单位为毫秒,该方法只能同步方法或同步块中调用,超过设置时间后线程重新进入可运行状态

　　　　方法说明：Note that the wait method, as it places the current thread into the wait set for this object, unlocks only this object; any other objects on 　　　　which the current thread may be synchronized remain locked while the thread waits. 

　　11、final wait(long timeout, int nanos)：不能被重写，在jdk1.8中看当，没有什么特殊作用类似 wait(long timeout)方法，片段12

if (nanos >= 500000 || (nanos != 0 && timeout == 0)) {
            timeout++;
 }

　　12、final void wait():：不能被重写，用于在线程调用中，导致当前线程进入阻塞状态（waiting）,该方法只能同步方法或同步块中调用，不会自动，片段13

　　　方法说明：The specified amount of real time has elapsed, more or less. If timeout is zero, however, then real time is not taken into consideration and the thread simply waits until notified.

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

　　　8,9,10,11,12几个方法一般配套使用，先了解一下JAVA 线程执行模型

　　

　　详细看示例 片段14

1 synchronized (obj) {
2          while (<condition does not hold>)
3              obj.wait(timeout);
4          ... // Perform action appropriate to condition
5 }

  View Code

　　执行wait过程中堆栈信息：

　　再来个生产消费者的示例 片段15

  View Code

 

　13、finalize():Object的protected方法，子类可以覆盖该方法以实现资源清理工作，GC在回收对象之前调用该方法

　　　　方法说明：Called by the garbage collector on an object when garbage collection determines that there are no more references to the object. A 　　　　subclass overrides the finalize method to dispose of system resources or to perform other cleanup. 

，该方法只能同步方法或同步块中调用

转载于:https://www.cnblogs.com/johnson341/p/7562138.html