1 static inline intptr_t get_next_hash(Thread * Self, oop obj) {
  2   intptr_t value = http://www.mamicode.com/0 ;
  3   if (hashCode == 0) {
  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 =http://www.mamicode.com/ os::random() ;
  9   } else
 10   if (hashCode == 1) {
 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) >> 3 ;
 15      value = http://www.mamicode.com/addrBits ^ (addrBits >> 5) ^ GVars.stwRandom ;
 16   } else
 17   if (hashCode == 2) {
 18      value = http://www.mamicode.com/1 ;            // for sensitivity testing
 19   } else
 20   if (hashCode == 3) {
 21      value = http://www.mamicode.com/++GVars.hcSequence ;
 22   } else
 23   if (hashCode == 4) {
 24      value =http://www.mamicode.com/ 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 << 11) ;
 31      Self->_hashStateX = Self->_hashStateY ;
 32      Self->_hashStateY = Self->_hashStateZ ;
 33      Self->_hashStateZ = Self->_hashStateW ;
 34      unsigned v = Self->_hashStateW ;
 35      v = (v ^ (v >> 19)) ^ (t ^ (t >> 8)) ;
 36      Self->_hashStateW = v ;
 37      value =http://www.mamicode.com/ v ;
 38   }
 39 
 40   value &= markOopDesc::hash_mask;
 41   if (value =http://www.mamicode.com/= 0) value = http://www.mamicode.com/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   }

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

 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    
42     public int getAge() {
43         return age;
44     }
45 
46     public void setAge(int age) {
47         this.age = age;
48     }
49 
50     public String getName() {
51         return name;
52     }
53 
54     public void setName(String name) {
55         this.name = name;
56     }
57 
58     public Race getRace() {
59         return race;
60     }
61 
62     public void setRace(Race race) {
63         this.race = race;
64     }
65     
66     public void setTestArray(int[] testArray) {
67         this.testArray = testArray;
68     }
69 
70     public int[] getTestArray() {
71         return testArray;
72     }    
73 
74 }
75 
76 class Race implements Cloneable {
77     String color; // 颜色
78     String distribution; // 分布
79 
80     public Race(String color, String distribution) {
81         super();
82         this.color = color;
83         this.distribution = distribution;
84     }
85 
86     public Race clone() throws CloneNotSupportedException {
87         return (Race) super.clone();
88     }
89 }

 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     
33     static class MyThreadFactory implements ThreadFactory {
34         
35         private final AtomicInteger threadNumber = new AtomicInteger(1);
36         
37         public Thread newThread(Runnable r) {
38           return new Thread(r, "mythiread - " + threadNumber.getAndIncrement());
39         }
40       }
41 }

 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 
27     public Producer(Queue<Integer> queue, int maxSize, String name) {
28         super(name);
29         this.maxSize = maxSize;
30         this.queue = queue;
31     }
32 
33     @Override
34     public void run() {
35         while (true) {
36 
37             synchronized (queue) {
38                 if (queue.size() == maxSize) {
39                     try {
40                         System.out.println("Queue is full, Producer wair for Comsumer to task something from queue");
41                         queue.wait();
42                     } catch (InterruptedException e) {
43                         e.printStackTrace();
44                     }
45                 }
46                 Random r = new Random();
47                 int value =http://www.mamicode.com/ r.nextInt();
48                 queue.add(value);
49                 System.out.println("Producer value : " + value);
50                 queue.notifyAll();
51             }
52         }
53     }
54 
55 }
56 
57 class Comsumer extends Thread {
58     private Queue<Integer> queue;
59     private int maxSize;
60 
61     public Comsumer(Queue<Integer> queue, int maxSize, String name) {
62         super(name);
63         this.maxSize = maxSize;
64         this.queue = queue;
65     }
66 
67     @Override
68     public void run() {
69         while (true) {
70 
71             synchronized (queue) {
72                 if (queue.isEmpty()) {
73                     try {
74                         System.out.println("Queue is enpty, Comsumer wair for Producer to put something in queue");
75                         queue.wait();
76                     } catch (InterruptedException e) {
77                         e.printStackTrace();
78                     }
79                 }
80                 System.out.println("Comsumer value : " + queue.remove());
81                 queue.notifyAll();
82             }
83         }
84     }
85 
86 }