最新在整体回归下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[]));
  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 ?  : ObjectSynchronizer::FastHashCode (THREAD, JNIHandles::resolve_non_null(handle)) ;
  5.  JVM_END

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

  1.  static inline intptr_t get_next_hash(Thread * Self, oop obj) {
  2.    intptr_t value =  ;
  3.    if (hashCode == ) {
  4.       // This form uses an unguarded global Park-Miller RNG,
  5.       // so it's possible for two threads to race and generate the same RNG.
  6.       // On MP system we'll have lots of RW access to a global, so the
  7.       // mechanism induces lots of coherency traffic.
  8.       value = os::random() ;
  9.    } else
  10.    if (hashCode == ) {
  11.       // This variation has the property of being stable (idempotent)
  12.       // between STW operations.  This can be useful in some of the 1-0
  13.       // synchronization schemes.
  14.       intptr_t addrBits = intptr_t(obj) >>  ;
  15.       value = addrBits ^ (addrBits >> ) ^ GVars.stwRandom ;
  16.    } else
  17.    if (hashCode == ) {
  18.       value =  ;            // for sensitivity testing
  19.    } else
  20.    if (hashCode == ) {
  21.       value = ++GVars.hcSequence ;
  22.    } else
  23.    if (hashCode == ) {
  24.       value = intptr_t(obj) ;
  25.    } else {
  26.       // Marsaglia's xor-shift scheme with thread-specific state
  27.       // This is probably the best overall implementation -- we'll
  28.       // likely make this the default in future releases.
  29.       unsigned t = Self->_hashStateX ;
  30.       t ^= (t << ) ;
  31.       Self->_hashStateX = Self->_hashStateY ;
  32.       Self->_hashStateY = Self->_hashStateZ ;
  33.       Self->_hashStateZ = Self->_hashStateW ;
  34.       unsigned v = Self->_hashStateW ;
  35.       v = (v ^ (v >> )) ^ (t ^ (t >> )) ;
  36.       Self->_hashStateW = v ;
  37.       value = v ;
  38.    }
  39.  
  40.    value &= markOopDesc::hash_mask;
  41.    if (value == ) value = 0xBAD ;
  42.    assert (value != markOopDesc::no_hash, "invariant") ;
  43.    TEVENT (hashCode: GENERATE) ;
  44.    return value;
  45.  }
  46.  //
  47.  intptr_t ObjectSynchronizer::FastHashCode (Thread * Self, oop obj) {
  48.    if (UseBiasedLocking) {
  49.      // NOTE: many places throughout the JVM do not expect a safepoint
  50.      // to be taken here, in particular most operations on perm gen
  51.      // objects. However, we only ever bias Java instances and all of
  52.      // the call sites of identity_hash that might revoke biases have
  53.      // been checked to make sure they can handle a safepoint. The
  54.      // added check of the bias pattern is to avoid useless calls to
  55.      // thread-local storage.
  56.      if (obj->mark()->has_bias_pattern()) {
  57.        // Box and unbox the raw reference just in case we cause a STW safepoint.
  58.        Handle hobj (Self, obj) ;
  59.        // Relaxing assertion for bug 6320749.
  60.        assert (Universe::verify_in_progress() ||
  61.                !SafepointSynchronize::is_at_safepoint(),
  62.               "biases should not be seen by VM thread here");
  63.        BiasedLocking::revoke_and_rebias(hobj, false, JavaThread::current());
  64.        obj = hobj() ;
  65.        assert(!obj->mark()->has_bias_pattern(), "biases should be revoked by now");
  66.      }
  67.    }
  68.  
  69.    // hashCode() is a heap mutator ...
  70.    // Relaxing assertion for bug 6320749.
  71.    assert (Universe::verify_in_progress() ||
  72.            !SafepointSynchronize::is_at_safepoint(), "invariant") ;
  73.    assert (Universe::verify_in_progress() ||
  74.            Self->is_Java_thread() , "invariant") ;
  75.    assert (Universe::verify_in_progress() ||
  76.           ((JavaThread *)Self)->thread_state() != _thread_blocked, "invariant") ;
  77.  
  78.    ObjectMonitor* monitor = NULL;
  79.    markOop temp, test;
  80.    intptr_t hash;
  81.    markOop mark = ReadStableMark (obj);
  82.  
  83.    // object should remain ineligible for biased locking
  84.    assert (!mark->has_bias_pattern(), "invariant") ;
  85.  
  86.    if (mark->is_neutral()) {
  87.      hash = mark->hash();              // this is a normal header
  88.      if (hash) {                       // if it has hash, just return it
  89.        return hash;
  90.      }
  91.      hash = get_next_hash(Self, obj);  // allocate a new hash code
  92.      temp = mark->copy_set_hash(hash); // merge the hash code into header
  93.      // use (machine word version) atomic operation to install the hash
  94.      test = (markOop) Atomic::cmpxchg_ptr(temp, obj->mark_addr(), mark);
  95.      if (test == mark) {
  96.        return hash;
  97.      }
  98.      // If atomic operation failed, we must inflate the header
  99.      // into heavy weight monitor. We could add more code here
  100.      // for fast path, but it does not worth the complexity.
  101.    } else if (mark->has_monitor()) {
  102.      monitor = mark->monitor();
  103.      temp = monitor->header();
  104.      assert (temp->is_neutral(), "invariant") ;
  105.      hash = temp->hash();
  106.      if (hash) {
  107.        return hash;
  108.      }
  109.      // Skip to the following code to reduce code size
  110.    } else if (Self->is_lock_owned((address)mark->locker())) {
  111.      temp = mark->displaced_mark_helper(); // this is a lightweight monitor owned
  112.      assert (temp->is_neutral(), "invariant") ;
  113.      hash = temp->hash();              // by current thread, check if the displaced
  114.      if (hash) {                       // header contains hash code
  115.        return hash;
  116.      }
  117.      // WARNING:
  118.      //   The displaced header is strictly immutable.
  119.      // It can NOT be changed in ANY cases. So we have
  120.      // to inflate the header into heavyweight monitor
  121.      // even the current thread owns the lock. The reason
  122.      // is the BasicLock (stack slot) will be asynchronously
  123.      // read by other threads during the inflate() function.
  124.      // Any change to stack may not propagate to other threads
  125.      // correctly.
  126.    }

　　该方法一般会被子类重写，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

  1. JVM_ENTRY(jobject, JVM_Clone(JNIEnv* env, jobject handle))
  2.   JVMWrapper("JVM_Clone");
  3.   Handle obj(THREAD, JNIHandles::resolve_non_null(handle));
  4.   const KlassHandle klass (THREAD, obj->klass());
  5.   JvmtiVMObjectAllocEventCollector oam;
  6.  
  7. #ifdef ASSERT
  8.   // Just checking that the cloneable flag is set correct
  9.   if (obj->is_javaArray()) {
  10.     guarantee(klass->is_cloneable(), "all arrays are cloneable");
  11.   } else {
  12.     guarantee(obj->is_instance(), "should be instanceOop");
  13.     bool cloneable = klass->is_subtype_of(SystemDictionary::Cloneable_klass());
  14.     guarantee(cloneable == klass->is_cloneable(), "incorrect cloneable flag");
  15.   }
  16. #endif
  17.  
  18.   // Check if class of obj supports the Cloneable interface.
  19.   // All arrays are considered to be cloneable (See JLS 20.1.5)
  20.   if (!klass->is_cloneable()) {
  21.     ResourceMark rm(THREAD);
  22.     THROW_MSG_0(vmSymbols::java_lang_CloneNotSupportedException(), klass->external_name());
  23.   }
  24.  
  25.   // Make shallow object copy
  26.   const int size = obj->size();
  27.   oop new_obj = NULL;
  28.   if (obj->is_javaArray()) {
  29.     const int length = ((arrayOop)obj())->length();
  30.     new_obj = CollectedHeap::array_allocate(klass, size, length, CHECK_NULL);
  31.   } else {
  32.     new_obj = CollectedHeap::obj_allocate(klass, size, CHECK_NULL);
  33.   }
  34.   // 4839641 (4840070): We must do an oop-atomic copy, because if another thread
  35.   // is modifying a reference field in the clonee, a non-oop-atomic copy might
  36.   // be suspended in the middle of copying the pointer and end up with parts
  37.   // of two different pointers in the field.  Subsequent dereferences will crash.
  38.   // 4846409: an oop-copy of objects with long or double fields or arrays of same
  39.   // won't copy the longs/doubles atomically in 32-bit vm's, so we copy jlongs instead
  40.   // of oops.  We know objects are aligned on a minimum of an jlong boundary.
  41.   // The same is true of StubRoutines::object_copy and the various oop_copy
  42.   // variants, and of the code generated by the inline_native_clone intrinsic.
  43.   assert(MinObjAlignmentInBytes >= BytesPerLong, "objects misaligned");
  44.   Copy::conjoint_jlongs_atomic((jlong*)obj(), (jlong*)new_obj,
  45.                                (size_t)align_object_size(size) / HeapWordsPerLong);
  46.   // Clear the header
  47.   new_obj->init_mark();
  48.  
  49.   // Store check (mark entire object and let gc sort it out)
  50.   BarrierSet* bs = Universe::heap()->barrier_set();
  51.   assert(bs->has_write_region_opt(), "Barrier set does not have write_region");
  52.   bs->write_region(MemRegion((HeapWord*)new_obj, size));
  53.  
  54.   // Caution: this involves a java upcall, so the clone should be
  55.   // "gc-robust" by this stage.
  56.   if (klass->has_finalizer()) {
  57.     assert(obj->is_instance(), "should be instanceOop");
  58.     new_obj = instanceKlass::register_finalizer(instanceOop(new_obj), CHECK_NULL);
  59.   }
  60.  
  61.   return JNIHandles::make_local(env, oop(new_obj));
  62. 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

  1.  package jdk;
  2.  
  3.  public class ObjectCloneTest2 {
  4.  
  5.      public static void main(String[] args) {
  6.          Animal a1 = new Animal(1, "pig");
  7.          Animal a2 = (Animal) a1.clone();
  8.          System.out.println(a1.getName() == a2.getName() ? "浅复制" : "深复制");
  9.  
  10.          System.out.println(a1);
  11.          a1.setAge(11);
  12.          a1.setName("big pig");
  13.          System.out.println(a1.age + ":" + a1.name);
  14.  
  15.          System.out.println(a2);
  16.          System.out.println(a2.age + ":" + a2.name);
  17.  
  18.      }
  19.  
  20.  }
  21.  
  22.  class Animal implements Cloneable{
  23.      int age;
  24.      String name;
  25.  
  26.      Animal(int age, String name) {
  27.          this.age = age;
  28.          this.name = name;
  29.      }
  30.  
  31.      public Animal clone() {
  32.          Animal o = null;
  33.  
  34.          try {
  35.              o = (Animal) super.clone();
  36.          } catch (CloneNotSupportedException e) {
  37.              e.printStackTrace();
  38.          }
  39.  
  40.          return o;
  41.      }
  42.  
  43.      public int getAge() {
  44.          return age;
  45.      }
  46.  
  47.      public void setAge(int age) {
  48.          this.age = age;
  49.      }
  50.  
  51.      public String getName() {
  52.          return name;
  53.      }
  54.  
  55.      public void setName(String name) {
  56.          this.name = name;
  57.      }
  58.  }

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

  1.  package jdk;
  2.  
  3.  public class ObjectCloneTest3 {
  4.  
  5.      public static void main(String[] args) {
  6.          Person p1 = new Person(10, "ll", new Race("yellow", "Asia"));
  7.          Person p2 = (Person) p1.clone();
  8.          System.out.println(p1.getRace() == p2.getRace());
  9.          System.out.println(p1.getTestArray() == p2.getTestArray());
  10.  
  11.      }
  12.  
  13.  }
  14.  
  15.  class Person implements Cloneable {
  16.      int age;
  17.      String name;
  18.      Race race;
  19.      int[] testArray = { 1, 23, 5, 6, 0 };
  20.  
  21.      Person(int age, String name, Race race) {
  22.          this.age = age;
  23.          this.name = name;
  24.          this.race = race;
  25.      }
  26.  
  27.      public Person clone() {
  28.          Person o = null;
  29.  
  30.          try {
  31.              o = (Person) super.clone();
  32.              o.setRace(this.race.clone());
  33.              o.setTestArray(testArray.clone());
  34.          } catch (CloneNotSupportedException e) {
  35.              e.printStackTrace();
  36.          }
  37.  
  38.          return o;
  39.      }
  40.  
  41.      public int getAge() {
  42.          return age;
  43.      }
  44.  
  45.      public void setAge(int age) {
  46.          this.age = age;
  47.      }
  48.  
  49.      public String getName() {
  50.          return name;
  51.      }
  52.  
  53.      public void setName(String name) {
  54.          this.name = name;
  55.      }
  56.  
  57.      public Race getRace() {
  58.          return race;
  59.      }
  60.  
  61.      public void setRace(Race race) {
  62.          this.race = race;
  63.      }
  64.  
  65.      public void setTestArray(int[] testArray) {
  66.          this.testArray = testArray;
  67.      }
  68.  
  69.      public int[] getTestArray() {
  70.          return testArray;
  71.      }    
  72.  
  73.  }
  74.  
  75.  class Race implements Cloneable {
  76.      String color; // 颜色
  77.      String distribution; // 分布
  78.  
  79.      public Race(String color, String distribution) {
  80.          super();
  81.          this.color = color;
  82.          this.distribution = distribution;
  83.      }
  84.  
  85.      public Race clone() throws CloneNotSupportedException {
  86.          return (Race) super.clone();
  87.      }
  88.  }

　　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:

  1.  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 wait methods.

　　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

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

　　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.  }
  1.  package jdk;
  2.  
  3.  import java.util.concurrent.ExecutorService;
  4.  import java.util.concurrent.Executors;
  5.  import java.util.concurrent.ThreadFactory;
  6.  import java.util.concurrent.atomic.AtomicInteger;
  7.  
  8.  public class ObjectWaitTest1 {
  9.      static Object lock = new Object();
  10.  
  11.      public static void main(String[] args) {
  12.  
  13.          ExecutorService executeService = Executors.newCachedThreadPool(new MyThreadFactory());
  14.          for (int i = 0; i < 10; i++) {
  15.              executeService.submit(() -> {
  16.                  synchronized (lock) {
  17.                      try {
  18.                          System.out.println(Thread.currentThread().getName() + " begin");
  19.                          lock.wait(1000 * 30); // wiat 30s
  20.                      } catch (Exception e) {
  21.                          e.printStackTrace();
  22.                      }
  23.  
  24.                      System.out.println(Thread.currentThread().getName() + " finish");
  25.                  }
  26.              });
  27.          }
  28.  
  29.          executeService.shutdown();
  30.      }
  31.  
  32.      static class MyThreadFactory implements ThreadFactory {
  33.  
  34.          private final AtomicInteger threadNumber = new AtomicInteger(1);
  35.  
  36.          public Thread newThread(Runnable r) {
  37.            return new Thread(r, "mythiread - " + threadNumber.getAndIncrement());
  38.          }
  39.        }
  40.  }

　　执行wait过程中堆栈信息：

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

  1.  package jdk;
  2.  
  3.  import java.util.LinkedList;
  4.  import java.util.Queue;
  5.  import java.util.Random;
  6.  
  7.  public class ObjectWaitTest2 {
  8.      static Object lock = new Object();
  9.  
  10.      public static void main(String[] args) {
  11.          int maxSize = 10;
  12.          Queue<Integer> buffer = new LinkedList<>();
  13.  
  14.          Thread producer = new Producer(buffer, maxSize, "Producer");
  15.          Thread comsuner = new Comsumer(buffer, maxSize, "comsuner");
  16.          producer.start();
  17.          comsuner.start();
  18.      }
  19.  
  20.  }
  21.  
  22.  class Producer extends Thread {
  23.      private Queue<Integer> queue;
  24.      private int maxSize;
  25.  
  26.      public Producer(Queue<Integer> queue, int maxSize, String name) {
  27.          super(name);
  28.          this.maxSize = maxSize;
  29.          this.queue = queue;
  30.      }
  31.  
  32.      @Override
  33.      public void run() {
  34.          while (true) {
  35.  
  36.              synchronized (queue) {
  37.                  if (queue.size() == maxSize) {
  38.                      try {
  39.                          System.out.println("Queue is full, Producer wair for Comsumer to task something from queue");
  40.                          queue.wait();
  41.                      } catch (InterruptedException e) {
  42.                          e.printStackTrace();
  43.                      }
  44.                  }
  45.                  Random r = new Random();
  46.                  int value = r.nextInt();
  47.                  queue.add(value);
  48.                  System.out.println("Producer value : " + value);
  49.                  queue.notifyAll();
  50.              }
  51.          }
  52.      }
  53.  
  54.  }
  55.  
  56.  class Comsumer extends Thread {
  57.      private Queue<Integer> queue;
  58.      private int maxSize;
  59.  
  60.      public Comsumer(Queue<Integer> queue, int maxSize, String name) {
  61.          super(name);
  62.          this.maxSize = maxSize;
  63.          this.queue = queue;
  64.      }
  65.  
  66.      @Override
  67.      public void run() {
  68.          while (true) {
  69.  
  70.              synchronized (queue) {
  71.                  if (queue.isEmpty()) {
  72.                      try {
  73.                          System.out.println("Queue is enpty, Comsumer wair for Producer to put something in queue");
  74.                          queue.wait();
  75.                      } catch (InterruptedException e) {
  76.                          e.printStackTrace();
  77.                      }
  78.                  }
  79.                  System.out.println("Comsumer value : " + queue.remove());
  80.                  queue.notifyAll();
  81.              }
  82.          }
  83.      }
  84.  
  85.  }

　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.

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

【java基础之jdk源码】Object的更多相关文章

  1. 【java基础之jdk源码】集合类

    最近在整理JAVA 基础知识,从jdk源码入手,今天就jdk中 java.util包下集合类进行理解 先看图 从类图结构可以了解 java.util包下的2个大类: 1.Collecton:可以理解为 ...

  2. java基础集合类——ArrayList 源码略读

    ArrayList是java的动态数组,底层是基于数组实现. 1. 成员变量 public class ArrayList<E> extends AbstractList<E> ...

  3. Java基础(八)--String(源码)、StringBuffer、StringBuilder

    String源码:基于jdk1.8 public final class String implements Serializable, Comparable<String>, CharS ...

  4. jdk源码Object类解析

    一 简介 java.lang.Object,是Java所有类的父类,在你编写一个类的时候,若无指定父类(没有显式extends一个父类),会默认的添加Object为该类的父类. 在JDK 6之前是编译 ...

  5. Java基础try-with-resource语法源码分析

    众所周知,所有被打开的系统资源,比如流.文件或者Socket连接等,都需要被开发者手动关闭,否则随着程序的不断运行,资源泄露将会累积成重大的生产事故. 在Java的江湖中,存在着一种名为finally ...

  6. JDK源码学习笔记——Object

    一.源码解析 public class Object { /** * 一个本地方法,具体是用C(C++)在DLL中实现的,然后通过JNI调用 */ private static native void ...

  7. 从JDK源码角度看Object

    Java的Object是所有其他类的父类,从继承的层次来看它就是最顶层根,所以它也是唯一一个没有父类的类.它包含了对象常用的一些方法,比如getClass.hashCode.equals.clone. ...

  8. 一点一点看JDK源码（三）java.util.ArrayList 前偏

    一点一点看JDK源码(三)java.util.ArrayList liuyuhang原创,未经允许禁止转载 本文举例使用的是JDK8的API 目录:一点一点看JDK源码(〇) 1.综述 ArrayLi ...

  9. Java中集合框架，Collection接口、Set接口、List接口、Map接口，已经常用的它们的实现类，简单的JDK源码分析底层实现

    (一)集合框架: Java语言的设计者对常用的数据结构和算法做了一些规范(接口)和实现(实现接口的类).所有抽象出来的数据结构和操作(算法)统称为集合框架. 程序员在具体应用的时候,不必考虑数据结构和 ...

随机推荐

  1. 大数据竞赛平台——Kaggle 入门

    Reference: http://blog.csdn.net/witnessai1/article/details/52612012 Kaggle是一个数据分析的竞赛平台,网址:https://ww ...

  2. win8.1 64位+oracle11g R2 64位 +powerdesigner破解版 64位+PL/SQL

    安装时搜索了很多帖子,很多就是复制粘贴(完全不需要什么IP,host),有的版本不对,有的版本太老,今天决定贴出自己的处女贴 oracle的安装很简单,不需要说什么了,PL/SQL真是恶心死 orac ...

  3. Reactive 网络状态 Activity indicator view

    转动属性:Animating RAC(self.searchActivity, hidden) = [self.m_viewModel.m_searchCommand.executing not];

  4. post请求时2种传参方式

    @Testpublic void dopost(){ String httpurl = "https://jin.caimao.com/api/user/loginSalt"; M ...

  5. Java中间件：淘宝网系统高性能利器（转）

    淘宝网是亚太最大的网络零售商圈,其知名度毋庸置疑,吸引着越来越多的消费者从街头移步这里,成为其忠实粉丝.如此多的用户和交易量,也意味着海量的信息处理,其背后的IT架构的稳定性.可靠性也显得尤为重要.那 ...

  6. .net 设置版本号信息

    1.AssemblyInfo.cs [assembly: AssemblyVersion("1.3.170116")] [assembly: AssemblyFileVersion ...

  7. javascript设计模式之解释器模式详解

    http://www.jb51.net/article/50680.htm 神马是“解释器模式”? 先翻开<GOF>看看Definition:给定一个语言,定义它的文法的一种表示,并定义一 ...

  8. 纯代码实现CSS圆角

    我这里说的是纯代码,是指的不使用图片实现圆角,图片实现圆角,这里就不说了. 纯代码实现圆角主要有3种方法: 第一种:CSS3圆角   #chaomao{     border-radius:2px 2 ...

  9. c#使用DotNetZip封装类操作zip文件(创建/读取/更新)实例

    DotnetZip是一个开源类库,支持.NET的任何语言,可很方便的创建,读取,和更新zip文件.而且还可以使用在.NETCompact Framework中.  下载地址在这里:http://dot ...

  10. 基于Ubuntu 14.04构建mysql5.6 Docker镜像

    我们的目的是创建一个基于Ubuntu 14.04 的MySQL的 Docker Image,并且在新创建出来的容器里自动启动MySQL服务接受外部连接 步骤: 1. 首先创建一个目录并在目录下创建一个 ...