1     /**
 2      * 普通同步辦法,鎖是當前實例對象
 3      */
 4     public synchronized void test1(){
 5         //TODO something
 6     }
 7 
 8     /**
 9      * 靜態同步辦法,鎖是當前類的Class對象
10      */
11     public static synchronized void test2(){
12         //TODO something
13     }
14 
15     /**
16      * 同步辦法塊,鎖是synchronized括號中的對象,這里是a
17      */
18     public void test3(Integer a){
19         synchronized (a){
20             //TODO something
21         }
22     }

 1 /**
 2  * @author zhouxuanyu
 3  * @date 2017/05/17
 4  */
 5 public class ThreadStatus {
 6     
 7     private String flag[] = { "true" };
 8     
 9     public static void main(String[] args) {
10         System.out.println("main thread start...");
11         ThreadStatus threadStatus = new ThreadStatus();
12         WaitThread waitThread = threadStatus.new WaitThread();
13         NotifyThread notifyThread = threadStatus.new NotifyThread();
14         waitThread.start();
15         notifyThread.start();
16     }
17     
18     class NotifyThread extends Thread {
19         
20         @Override
21         public void run() {
22             synchronized (flag) {
23                 for (int i = 0; i < 5; i++) {
24                     try {
25                         sleep(1000);
26                     } catch (InterruptedException e) {
27                         e.printStackTrace();
28                     }
29                     System.out.println("NotifyThread.run()---" + i);
30                 }
31                 flag[0] = "false";
32                 flag.notify();
33             }
34         }
35     }
36     
37     class WaitThread extends Thread {
38         
39         @Override
40         public void run() {
41             //使用flag使得線程獲得鎖
42             synchronized (flag) {
43                 while (flag[0] != "false") {
44                     System.out.println("WaitThread.run.....");
45                     try {
46                         flag.wait();
47                     } catch (InterruptedException e) {
48                         e.printStackTrace();
49                     }
50                 }
51                 System.out.println("wait() end...");
52             }
53         }
54     }
55 }

 1     /** 
 2      * Associates the specified value with the specified key in thismap. 
 3      * If the map previously contained a mapping for the key, the old 
 4      * value is replaced. 
 5      * 
 6      */  
 7 public V put(K key, V value) {  
 8         return putVal(hash(key), key, value, false, true);  
 9     }  
10 static final int hash(Object key) {  
11         int h;  
12         //key的值為null時,hash值返回0,對應的table數組中的位置是0  
13         return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);  
14     }  
15   
16 /** 
17      * Implements Map.put and related methods 
18      * 
19      * @param hash hash for key 
20      * @param key the key 
21      * @param value the value to put 
22      * @param onlyIfAbsent if true, don't change existing value 
23      * @param evict if false, the table is in creation mode. 
24      * @return previous value, or null if none 
25  */  
26 final V putVal(int hash, K key, V value, boolean onlyIfAbsent,  
27                    boolean evict) {  
28         Node<K,V>[] tab; Node<K,V> p; int n, i;  
29 //先將table賦給tab,判斷table是否為null或大小為0,若為真,就調用resize()初始化  
30         if ((tab = table) == null || (n = tab.length) == 0)  
31             n = (tab = resize()).length;  
32 //通過i = (n - 1) & hash得到table中的index值,若為null,則直接添加一個newNode  
33         if ((p = tab[i = (n - 1) & hash]) == null)  
34             tab[i] = newNode(hash, key, value, null);  
35         else {  
36         //執行到這里,說明發生碰撞,即tab[i]不為空,需要組成單鏈表或紅黑樹  
37             Node<K,V> e; K k;  
38             if (p.hash == hash &&  
39                 ((k = p.key) == key || (key != null && key.equals(k))))  
40 //此時p指的是table[i]中存儲的那個Node,如果待插入的節點中hash值和key值在p中已經存在,則將p賦給e  
41                 e = p;  
42 //如果table數組中node類的hash、key的值與將要插入的Node的hash、key不吻合,就需要在這個node節點鏈表或者樹節點中查找.  
43             else if (p instanceof TreeNode)  
44             //當p屬于紅黑樹結構時,則按照紅黑樹方式插入  
45                 e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);  
46             else {  
47     //到這里說明碰撞的節點以單鏈表形式存儲,for循環用來使單鏈表依次向后查找  
48                 for (int binCount = 0; ; ++binCount) {  
49         //將p的下一個節點賦給e,如果為null,創建一個新節點賦給p的下一個節點  
50                     if ((e = p.next) == null) {  
51                         p.next = newNode(hash, key, value, null);  
52         //如果沖突節點達到8個,調用treeifyBin(tab, hash),這個treeifyBin首先回去判斷當前hash表的長度,如果不足64的話,實際上就只進行resize,擴容table,如果已經達到64,那么才會將沖突項存儲結構改為紅黑樹.  
53   
54                         if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st  
55                             treeifyBin(tab, hash);  
56                         break;  
57                     }  
58 //如果有相同的hash和key,則退出循環  
59                     if (e.hash == hash &&  
60                         ((k = e.key) == key || (key != null && key.equals(k))))  
61                         break;  
62                     p = e;//將p調整為下一個節點  
63                 }  
64             }  
65 //若e不為null,表示已經存在與待插入節點hash、key相同的節點,hashmap后插入的key值對應的value會覆蓋以前相同key值對應的value值,就是下面這塊代碼實現的  
66             if (e != null) { // existing mapping for key  
67                 V oldValue = e.value;  
68         //判斷是否修改已插入節點的value  
69                 if (!onlyIfAbsent || oldValue == null)  
70                     e.value = value;  
71                 afterNodeAccess(e);  
72                 return oldValue;  
73             }  
74         }  
75         ++modCount;//插入新節點后,hashmap的結構調整次數+1  
76         if (++size > threshold)  
77             resize();//HashMap中節點數+1,如果大于threshold,那么要進行一次擴容  
78         afterNodeInsertion(evict);  
79         return null;  
80     }