一、概述
1.很多人看源代碼只是單純的看，也許並不知道爲什麼要看源代碼。jdk源代碼是經過很多大牛無數次的版本升級、更新最後沉澱下來的精華，如果只是單純的爲了熟悉這個api。完全不需要看源代碼，只需要記住api文檔就行。看源代碼有兩個好處。
a.能夠學習大牛的設計思想，它爲什麼是這樣設計的，而不是那樣設計的，這個也是最重要的。
b.當然在看我一遍源代碼後，對裏面的方法也更加熟悉，運行也更加熟練，排查問題的能力也能得到提升。
2.不光HashMap在jdk1.8前後有了變化，ConcurrentHashMap也在jdk1.8前後大有不同
3.在jdk1.8之前。ConcurrentHashMap採用的數據結構是數組加鏈表。
採用的鎖機制，是分段鎖。將一個數組，分成很多段，每一段都相當於一個HashTable。HashTable採用的是全局鎖。當多線程訪問時，只要線程兩個線程訪問的不是同一段數據，便能異步執行。但是這種設計性能將會受到分段個數的數量而限制。如下圖，此時分段個數最多爲5，也就意味着最多5個線程異步進行操作。
３.所以在jdk1.8放棄了分段鎖，而採用CAS算法和synchorized關鍵字。
jdk1.8採用的數據結構和HashMap一致，也是使用的數組加紅黑樹加鏈表。對插入元素，如過Node節點爲null,則使用CAS算法進行插入，如果節點不爲空，則表示該桶裏面要麼是鏈表，要麼是紅黑樹，則使用java關鍵字synchorized將node節點鎖住。如果沒有發生衝突，則意味着我們的map不會有重量級鎖（synchorized）
４.jdk1,8前後進行比較，則可以看出，以前的併發受分段個數的限制，現在的併發，只要不是同一個節點（桶），便能同時執行插入操作。
二、源碼
1.常量，之前HashMap中介紹
在講解方法之前，我們有必要先了解一下常用的常量和變量，以便在後面的方法中我們不至於對這變量的用途不瞭解。
1). java虛擬機限制數組的最大使用長度
static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
2).只有當數組容量大於該值時，才允許樹行化鏈表（即將鏈表轉換爲紅黑樹），否則直接進行擴容，不需要轉換成紅黑樹。
static final int MIN_TREEIFY_CAPACITY = 64;
3).用於生成每次擴容都唯一的生成戳的數，最小是6。
private static int RESIZE_STAMP_BITS = 16;
4).最大擴容線程數量
private static final int MAX_RESIZERS = (1 << (32 - RESIZE_STAMP_BITS)) - 1;
5).獲取cpu的數量
static final int NCPU = Runtime.getRuntime().availableProcessors();
6).特殊節點的hash值，正常hash不會出現負數，forwarding nodes是一個臨時節點，在擴容中出現
如果舊數組需要將全部節點轉移到新數組，會在舊數組放置一個forwarding nodes節點
若讀操作碰到該節點時，則將操作轉發到擴容後的新數組執行，如果是寫操作碰到，則嘗試幫助擴容
static final int MOVED = -1; // hash for forwarding nodes
static final int TREEBIN = -2; // hash for roots of trees
static final int RESERVED = -3; // hash for transient reservations
static final int HASH_BITS = 0x7fffffff; // usable bits of normal node hash
2.變量
1).擴容後新的table數組，只有在擴容時使用，若nextTable不爲空，則表示擴容未結束
private transient volatile Node<K,V>[] nextTable;
2). sizeCtl = -1，表示有線程正在進行真正的初始化操作
sizeCtl = -(1 + nThreads)，表示有nThreads個線程正在進行擴容操作
sizeCtl > 0，表示接下來的真正的初始化操作中使用的容量，或者初始化/擴容完成後的threshold
sizeCtl = 0，默認值，此時在真正的初始化操作中使用默認容量
private transient volatile int sizeCtl;
3.方法
1.)
a.unsafe類，是一個可以直接操控內存的類。不對外提供構造方法。但提供了getUnsafe的方法來獲取對象。所以這裏unsafe對象只能從啓動類加載器加載，
b.而啓動類加載器：這個類加載器負責放在<JAVA_HOME>\lib目錄中的，或者被-Xbootclasspath參數所指定的路徑中的，並且是虛擬機識別的類庫。用戶無法直接使用。
c.用戶能直接使用的只有擴展類加載器和應用類加載器，這種設計無疑爲類提供更安全的訪問限制。
d.objectFieldOffset方法，獲取對象內存地址該字段的偏移量。其實就是獲取字段的內存地址。
private static final sun.misc.Unsafe U;
private static final long SIZECTL;
private static final long TRANSFERINDEX;
private static final long BASECOUNT;
private static final long CELLSBUSY;
private static final long CELLVALUE;
private static final long ABASE;
private static final int ASHIFT;
static {
try {
U = sun.misc.Unsafe.getUnsafe();
Class<?> k = ConcurrentHashMap.class;
SIZECTL = U.objectFieldOffset
(k.getDeclaredField("sizeCtl"));
TRANSFERINDEX = U.objectFieldOffset
(k.getDeclaredField("transferIndex"));
BASECOUNT = U.objectFieldOffset
(k.getDeclaredField("baseCount"));
CELLSBUSY = U.objectFieldOffset
(k.getDeclaredField("cellsBusy"));
Class<?> ck = CounterCell.class;
CELLVALUE = U.objectFieldOffset
(ck.getDeclaredField("value"));
Class<?> ak = Node[].class;
ABASE = U.arrayBaseOffset(ak);
int scale = U.arrayIndexScale(ak);
if ((scale & (scale - 1)) != 0)
throw new Error("data type scale not a power of two");
ASHIFT = 31 - Integer.numberOfLeadingZeros(scale);
} catch (Exception e) {
throw new Error(e);
}
}
2).putVal方法map中一個非常重要的方法，爲了方便閱讀，我對每一句代碼進行了註釋，先看一下它是怎麼運行的，最好再來說它爲什麼這麼設計。
//put方法；參數：onlyIfAbsent，如果key相同，是否覆蓋原來的值,false表示覆蓋
final V putVal(K key, V value, boolean onlyIfAbsent) {
//如果傳入key或value爲空，拋異常，所以ConcurrentHashMap不允許鍵或值爲null
if (key == null || value == null) throw new NullPointerException();
//計算key的hash值
int hash = spread(key.hashCode());
int binCount = 0;
for (Node<K,V>[] tab = table;;) {
//聲明變量f表示桶，ｎ是table的長度,i是node的下標，fn是node的hash值
Node<K,V> f; int n, i, fh;
//如果table爲空，則進行初始化，然後繼續循環，所以上面是循環tab = table
if (tab == null || (n = tab.length) == 0)
tab = initTable();
//如果通過hash找到的下標爲null
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
//通過CAS算法將鍵值插入到tab數組中，然後跳出（後面講這個方法）
if (casTabAt(tab, i, null,
new Node<K,V>(hash, key, value, null)))
break; // no lock when adding to empty bin
}
//如果hash值爲-1，則表明是一個特殊的ForwardingNode節點
//如果是讀操作，則到新數組中去執行
//這裏是寫操作，則幫助擴容
else if ((fh = f.hash) == MOVED)
//數組擴容，幫助擴容
tab = helpTransfer(tab, f);
//如果下標內容不爲空，則進行的操作
else {
V oldVal = null;
//對這個桶的Node節點f加鎖。
synchronized (f) {
if (tabAt(tab, i) == f) {
//node的hash值大於0,表示不是特殊節點
if (fh >= 0) {
binCount = 1;
for (Node<K,V> e = f;; ++binCount) {
//聲明變量k
K ek;
//如果hash值相同，key的比較也相同，把舊值賦值給oldVal
if (e.hash == hash &&
((ek = e.key) == key ||
(ek != null && key.equals(ek)))) {
oldVal = e.val;
//put方法傳入的onlyIfAbsent爲false，則將新值給覆蓋 //掉舊值
if (!onlyIfAbsent)
e.val = value;
break;
}
//如果不爲空，遍歷鏈表，找到空的地址，進行新增
Node<K,V> pred = e;
if ((e = e.next) == null) {
pred.next = new Node<K,V>(hash, key,
value, null);
break;
}
}
}
//如果節點爲紅黑樹的節點
else if (f instanceof TreeBin) {
Node<K,V> p;
binCount = 2;
//將節點新增到紅黑樹中
if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
value)) != null) {
oldVal = p.val;
if (!onlyIfAbsent)
p.val = value;
}
}
}
}
if (binCount != 0) {
//bintCount在鏈表中，初始值爲１，循環一次加１，則表示鏈表的長度是否大於８
if (binCount >= TREEIFY_THRESHOLD)
//將該桶轉換成紅黑樹
treeifyBin(tab, i);
if (oldVal != null)
return oldVal;
break;
}
}
}
addCount(1L, binCount);
return null;
}
3). initTable()方法，是對容器進行初始化的操作。
//使用sizeCtl中記錄的大小初始化表。
private final Node<K,V>[] initTable() {
Node<K,V>[] tab; int sc;
while ((tab = table) == null || tab.length == 0) {
if ((sc = sizeCtl) < 0)
Thread.yield(); // lost initialization race; just spin
else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
try {
if ((tab = table) == null || tab.length == 0) {
int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
@SuppressWarnings("unchecked")
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
table = tab = nt;
sc = n - (n >>> 2);
}
} finally {
sizeCtl = sc;
}
break;
}
}
return tab;
}
4).在put方法和iniTable方法中都有使用到CAS算法，來看一下CAS算法究竟是什麼。下面這是方法是在putVal中使用的一個方法。
目的是新建一個node節點插入到數組下標。
static final <K,V> boolean casTabAt(Node<K,V>[] tab, int i,
Node<K,V> c, Node<K,V> v) {
return U.compareAndSwapObject(tab, ((long)i << ASHIFT) + ABASE, c, v);
}
5).unsafe類的對象在靜態代碼塊中已經獲取到了，所以只需要調用它的方法即可，每一個參數都在代碼中標明瞭註釋。
/* 在obj的offset位置比較object field和期望的值，如果相同則更新。這個方法
* 的操作應該是原子的，因此提供了一種不可中斷的方式更新object field。
*
* @param obj the object containing the field to modify.
* 包含要修改field的對象
* @param offset the offset of the object field within <code>obj</code>.
* <code>obj</code>中object型field的偏移量
* @param expect the expected value of the field.
* 希望field中存在的值
* @param update the new value of the field if it equals <code>expect</code>.
* 如果期望值expect與field的當前值相同，設置filed的值爲這個新值
* @return true if the field was changed.
* 如果field的值被更改
*/
public native boolean compareAndSwapObject(Object obj, long offset,
Object expect, Object update);
compareAndSwapObject(tab, ((long)i << ASHIFT) + ABASE, c, v);這是map調用的,用來更新對象爲tab，我們來看一下這幾個參數分別是什麼。
a.tab:要跟新的對象
b.((long)i << ASHIFT) + ABASE:這個值獲取的是該對象給定數組下標的實際內存地址，接着細看一下，這幾個值是怎麼來的。
首先：scale:獲取用戶給定數組尋址的換算因子
Class<?> ak = Node[].class;
int scale = U.arrayIndexScale(ak);
然後：ASHIFT:通過換算因子獲取第一個元素的偏移地址。
ABASE = U.arrayBaseOffset(ak);
Integer.numberOfLeadingZeros(scale)
ASHIFT = 31 - Integer.numberOfLeadingZeros(scale);
最後：看一下numberOfLeadingZeros(scale)這個方法的作用
該方法的作用是返回無符號整型i的最高非零位前面的0的個數，包括符號位在內；
如果i爲負數，這個方法將會返回0，符號位爲1.
比如說，10的二進制表示爲 0000 0000 0000 0000 0000 0000 0000 1010
java的整型長度爲32位。那麼這個方法返回的就是28
Integer.numberOfLeadingZeros(scale)
c.參數c爲null,我們期望是null,如果當實際地址的內容也是null時，則進行跟新。
d.new Node<K,V>(hash, key, value, null)這是ｖ。表示將這個node對象更新到指定的內存。
6.當然iniTable方法裏面使用的那個unsafe類方法也是同樣的道理，使用的是原子操作。
7.這樣就實現了更新數組某個下標的內容，但是爲什麼要這麼做了，搞這麼複雜，因爲unsafe類裏面的方法使用的是CAS算法，都是原子操作，如果不這麼做，那麼我們勢必得給這個更新操作加鎖，在性能方法不佳。
8. 當然在ConcurrentHashMap中還有很多方法都很經典，一兩篇博客肯定是寫不完的，有興趣的可以自己下來分析下那些源代碼。
四、爲什麼這麼設計
1.有一個java面試題我記得是這樣問的，請你談談ConcurrentHashMap實現原理，爲什麼在jdk1.8之後放棄了分段鎖，如果是你來設計，你會怎麼設計。
答案：
ConcurrentHashMap這個類屬於併發容器，主要用於在多線程情況下對數據進行map類型的數據進行存儲。在多線程情況勢必需要考慮線程安全問題。一個全局的synchronized可以搞定，但是在考慮安全的同時也得考慮性能，最好的設計是在線程安全的情況下性能最優。jdk1.8之前使用分段鎖，線程的並非受到了鎖個數的現在，而且synchronized屬於重量級鎖，在性能方面並不好。放棄了分段鎖。使用CAS算法，代表着分段個數永遠是數值的長度，而且並不會帶來重量級鎖性能限制的條件，當然如果發生了hash衝突，還是得采用原始的synchorized。
如果是我來設計，在結構這方面不需要改變，要想性能更上一步，就得避免synchorized的使用，也就意味着需要儘可能的不發生hash衝突。需要做的是在hash算法這一部分還能夠儘量優化，以此來提高性能。
最後，如果你對文章內容還稍微滿意，希望得到更大的提升，可以獲取更多的學習資料，面試題以及視頻，關注微信公衆號，將定時更新各種技術文章，提升知識。
