（一）基於JDK1.7的ConcurrentHashMap
1.基本實現：
由Segement數組和HashEntry組成，與HashMap相同都是數組+鏈表的結構，而每一個Segment元素存儲的是HashEntry數組+鏈表，這個和HashMap的數據存儲結構一樣
Segement:
static final class Segment<K,V> extends ReentrantLock implements Serializable {
private static final long serialVersionUID = 2249069246763182397L;
// 真正存放數據的桶
transient volatile HashEntry<K,V>[] table;
transient int count;
transient int modCount;
transient int threshold;//擴容閾值
final float loadFactor;//加載因子
}
hashEntry：
static final class HashEntry<K,V> {
final int hash;
// key值初始化後不能改變
final K key;
//volatile保證讀到的數據爲最新值
volatile V value;
//volatile保證讀到的數據爲最新的
volatile HashEntry<K,V> next;
}
關係如圖所示：
鎖分段技術：HashTable效率低下的原因是多個線程競爭同一把鎖，而ConcurrentHashMap把數據分成了一段一段的存儲，每一段數據都分給一把鎖，當一段數據被一個線程訪問時，其他段的數據也能被其他線程所訪問。
2.ConcurrentHashMap實現存儲和讀取：
1.put（）
public V put(K key, V value) {
Segment<K,V> s;
if (value == null)
throw new NullPointerException();
int hash = hash(key);
int j = (hash >>> segmentShift) & segmentMask;
if ((s = (Segment<K,V>)UNSAFE.getObject // nonvolatile; recheck
(segments, (j << SSHIFT) + SBASE)) == null) // in ensureSegment
s = ensureSegment(j);
return s.put(key, hash, value, false);
}
先通過key定位到Segement，之後再具體Segement進行具體的添加：
先進行再散列：減少散列衝突，使元素均勻的分佈在不同的Segment上，從而提高容器的存取效率
通過散列算法定位： segments[(hash>>>segmentShift)&segementMask]
1 final V put(K key, int hash, V value, boolean onlyIfAbsent) {
2 HashEntry<K,V> node = tryLock() ? null :
3 scanAndLockForPut(key, hash, value);
4 V oldValue;
5 try {
6 HashEntry<K,V>[] tab = table;
7 int index = (tab.length - 1) & hash;
8 HashEntry<K,V> first = entryAt(tab, index);
9 for (HashEntry<K,V> e = first;;) {
10 if (e != null) {
11 K k;
12 if ((k = e.key) == key ||
13 (e.hash == hash && key.equals(k))) {
14 oldValue = e.value;
15 if (!onlyIfAbsent) {
16 e.value = value;
17 ++modCount;
18 }
19 break;
20 }
21 e = e.next;
22 }
23 else {
24 if (node != null)
25 node.setNext(first);
26 else
27 node = new HashEntry<K,V>(hash, key, value, first);
28 int c = count + 1;
29 if (c > threshold && tab.length < MAXIMUM_CAPACITY)
30 rehash(node);
31 else
32 setEntryAt(tab, index, node);
33 ++modCount;
34 count = c;
35 oldValue = null;
36 break;
37 }
38 }
39 } finally {
40 unlock();
41 }
42 return oldValue;
43 }
首先嚐試獲取鎖，如果獲取失敗則調用scanAndLockForPut（）自旋獲取鎖。
scanAndLockForPut
private HashEntry<K,V> scanAndLockForPut(K key, int hash, V value) {
HashEntry<K,V> first = entryForHash(this, hash);
HashEntry<K,V> e = first;
HashEntry<K,V> node = null;
int retries = -1; // 定位節點時爲負數
//(1)
while (!tryLock()) {
HashEntry<K,V> f; // 首先在下面重新檢查
if (retries < 0) {
if (e == null) {
if (node == null) // 推測性地創建節點
node = new HashEntry<K,V>(hash, key, value, null);
retries = 0;
}
else if (key.equals(e.key))
retries = 0;
else
e = e.next;
}
//(2)
else if (++retries > MAX_SCAN_RETRIES) {
lock();
break;
}
else if ((retries & 1) == 0 &&
(f = entryForHash(this, hash)) != first) {
e = first = f; // 如果Entry改變則重新遍歷
retries = -1;
}
}
return node;
}
代碼（1）嘗試自旋獲取鎖。
代碼（2）如果重試的次數達到了 MAX_SCAN_RETRIES 則改爲阻塞鎖獲取，保證能獲取成功。
流程：
1.首先嚐試獲取鎖，如果獲取失敗說明與其它線程存在競爭，則調用scanAndLockForPut()
2. 計算HashEntry的數組下標並定位到HashEntry鏈表的首節點
3.遍歷鏈表，如果不爲空則比較key是否相同，相同則覆蓋
4.爲空創建一個新的結點並添加到hash鏈的頭部
5.判斷元素個數是否超過擴容閾值，超過則調用resize擴容
6.最後釋放鎖
2.get（）
1 public V get(Object key) {
2 Segment<K,V> s; // manually integrate access methods to reduce overhead
3 HashEntry<K,V>[] tab;
4 int h = hash(key);
5 long u = (((h >>> segmentShift) & segmentMask) << SSHIFT) + SBASE;
6 if ((s = (Segment<K,V>)UNSAFE.getObjectVolatile(segments, u)) != null &&
7 (tab = s.table) != null) {
8 for (HashEntry<K,V> e = (HashEntry<K,V>) UNSAFE.getObjectVolatile
9 (tab, ((long)(((tab.length - 1) & h)) << TSHIFT) + TBASE);
10 e != null; e = e.next) {
11 K k;
12 if ((k = e.key) == key || (e.hash == h && key.equals(k)))
13 return e.value;
14 }
15 }
16 return null;
17 }
通過key的hash值，調用UNSAFE.getObjectVolatile方法，由於是volatile版本，可以實現線程之間的可見性（遵循happend-before原則），故可以從最新的segments數組中獲取該key所在的segment；
然後根據key的hash值，獲取該segment內部的哈希表table數組的下標，從而獲取該key所在的鏈表的頭結點，然後從鏈表頭結點開始遍歷該鏈表，最終如果沒有找到，則返回null或者找到對應的鏈表節點，返回該鏈表節點的value。
3.size：
一開始並不對Segment加鎖，而是直接嘗試將所有的Segment元素中的count相加，這樣執行兩次，然後將兩次的結果對比，如果兩次結果相等則直接返回；而如果兩次結果不同，則再將所有Segment加鎖（將所有segement的put，remove，clean都鎖住），然後再執行統計得到對應的size值
（二）基於JDK1.8的ConcurrentHashMap
1.重要概念： 採用Node+CAS+Synchronized來保證併發安全的實現。
2.put方法
public V put(K key, V value) {
return putVal(key, value, false);
}
/** Implementation for put and putIfAbsent */
final V putVal(K key, V value, boolean onlyIfAbsent) {
if (key == null || value == null) throw new NullPointerException();
int hash = spread(key.hashCode()); //兩次hash，減少hash衝突，可以均勻分佈
int binCount = 0;
for (Node<K,V>[] tab = table;;) { //對這個table進行迭代
Node<K,V> f; int n, i, fh;
//這裏就是上面構造方法沒有進行初始化，在這裏進行判斷，爲null就調用initTable進行初始化，屬於懶漢模式初始化
if (tab == null || (n = tab.length) == 0)
tab = initTable();
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {//如果i位置沒有數據，就直接無鎖插入
if (casTabAt(tab, i, null,
new Node<K,V>(hash, key, value, null)))
break; // no lock when adding to empty bin
}
else if ((fh = f.hash) == MOVED)//如果在進行擴容，則先進行擴容操作
tab = helpTransfer(tab, f);
else {
V oldVal = null;
//如果以上條件都不滿足，那就要進行加鎖操作，也就是存在hash衝突，鎖住鏈表或者紅黑樹的頭結點
synchronized (f) {
if (tabAt(tab, i) == f) {
if (fh >= 0) { //表示該節點是鏈表結構
binCount = 1;
for (Node<K,V> e = f;; ++binCount) {
K ek;
//這裏涉及到相同的key進行put就會覆蓋原先的value
if (e.hash == hash &&
((ek = e.key) == key ||
(ek != null && key.equals(ek)))) {
oldVal = e.val;
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) { //如果鏈表的長度大於8時就會進行紅黑樹的轉換
if (binCount >= TREEIFY_THRESHOLD)
treeifyBin(tab, i);
if (oldVal != null)
return oldVal;
break;
}
}
}
addCount(1L, binCount);//統計size，並且檢查是否需要擴容
return null;
}
流程：
1.先對key的hashcode進行第二次hash，減少哈希衝突
2.如果table沒有初始化，則調用initTable進行table的初始化
3.如果table的i位置沒有數據，則直接進行無鎖插入（調用casTabAt）
4.判斷是否在進行擴容，如果是則協助擴容
5.以上條件都不滿足，則使用synchronized進行加鎖操作
6.如果是鏈表則進行鏈表的插入，如果是紅黑樹則進行紅黑樹的插入操作
7.如果鏈表的個數是否大於閾值，大於則轉換爲紅黑樹
8.最後調用addCount，統計size，檢查否需要擴容
initable:
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();
//正在初始化時將sizeCtl設爲-1
else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
/*
unsafe.compareAndSwapInt這個方法，這個方法有四個參數，其中第一個參數爲需要改變的對象，第二個爲偏移量(即之前求出來的valueOffset的值)，第三個參數爲期待的值，第四個爲更新後的值
*/
try {
if ((tab = table) == null || tab.length == 0) {
int n = (sc > 0) ? sc : DEFAULT_CAPACITY; //DEFAULT_CAPACITY爲16
@SuppressWarnings("unchecked")
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
table = tab = nt;
sc = n - (n >>> 2); //擴容閾值爲新容量的0.75倍
}
} finally {
sizeCtl = sc; //擴容保護
}
break;
}
}
return tab;
}
table的初始化時未加鎖的，當腰初始化的時候調用compareAndSwapInt將sizeCtl視爲-1，sizeCtl由votaile修飾，保證了可見性，因而別的線程再調用次方法時會執行Thread.yield（）
addCount
3.擴容實現：
1.擴容時機：
1.調用put後會調用addCount（），內部檢查sizeCtl是否需要擴容
2.鏈表轉紅黑樹時如果table容量小於64
3.調用putAll（）之類一次性加入大量元素
2.總體思想：分工合作，多個線程一個協作擴容，將表拆分，讓每個線程處理自己的區間
3.重要屬性：
1. sizeCtl：控制標誌符
當前未初始化：
=0 未指定初始化容量
>0由指定的初始化容量計算，再尋找最近的2的冪次
初始化中：
-1 table正在初始化
-N 表示正有N-1個線程執行擴容操作
初始化完成：
=table.length*0.75
2.static變量：
// 用於生成每次擴容都唯一的生成戳的數，最小是6。
private static int RESIZE_STAMP_BITS = 16;
// 最大的擴容線程的數量
private static final int MAX_RESIZERS = (1 << (32 - RESIZE_STAMP_BITS)) - 1;
// 移位量，把生成戳移位後保存在sizeCtl中當做擴容線程計數的基數，相反方向移位後能夠反解出生成戳
private static final int RESIZE_STAMP_SHIFT = 32 - RESIZE_STAMP_BITS;
3.
4.
5.transfer方法
private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
int n = tab.length, stride;
// 每核處理的量小於16，則強制賦值16
if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
stride = MIN_TRANSFER_STRIDE; // subdivide range
if (nextTab == null) { // initiating
try {
@SuppressWarnings("unchecked")
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n << 1]; //構建一個nextTable對象，其容量爲原來容量的兩倍
nextTab = nt;
} catch (Throwable ex) { // try to cope with OOME
sizeCtl = Integer.MAX_VALUE;
return;
}
nextTable = nextTab;
transferIndex = n;
}
int nextn = nextTab.length;
// 連接點指針，用於標誌位（fwd的hash值爲-1，fwd.nextTable=nextTab）
ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);
// 當advance == true時，表明該節點已經處理過了
boolean advance = true;
boolean finishing = false; // to ensure sweep before committing nextTab
for (int i = 0, bound = 0;;) {
Node<K,V> f; int fh;
// 控制 --i ,遍歷原hash表中的節點
while (advance) {
int nextIndex, nextBound;
if (--i >= bound || finishing)
advance = false;
else if ((nextIndex = transferIndex) <= 0) {
i = -1;
advance = false;
}
// 用CAS計算得到的transferIndex
else if (U.compareAndSwapInt
(this, TRANSFERINDEX, nextIndex,
nextBound = (nextIndex > stride ?
nextIndex - stride : 0))) {
bound = nextBound;
i = nextIndex - 1;
advance = false;
}
}
if (i < 0 || i >= n || i + n >= nextn) {
int sc;
// 已經完成所有節點複製了
if (finishing) {
nextTable = null;
table = nextTab; // table 指向nextTable
sizeCtl = (n << 1) - (n >>> 1); // sizeCtl閾值爲原來的1.5倍
return; // 跳出死循環，
}
// CAS 更擴容閾值，在這裏面sizectl值減一，說明新加入一個線程參與到擴容操作
if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)
return;
finishing = advance = true;
i = n; // recheck before commit
}
}
// 遍歷的節點爲null，則放入到ForwardingNode 指針節點
else if ((f = tabAt(tab, i)) == null)
advance = casTabAt(tab, i, null, fwd);
// f.hash == -1 表示遍歷到了ForwardingNode節點，意味着該節點已經處理過了
// 這裏是控制併發擴容的核心
else if ((fh = f.hash) == MOVED)
advance = true; // already processed
else {
// 節點加鎖
synchronized (f) {
// 節點複製工作
if (tabAt(tab, i) == f) {
Node<K,V> ln, hn;
// fh >= 0 ,表示爲鏈表節點
if (fh >= 0) {
// 構造兩個鏈表 一個是原鏈表 另一個是原鏈表的反序排列
int runBit = fh & n;
Node<K,V> lastRun = f;
for (Node<K,V> p = f.next; p != null; p = p.next) {
int b = p.hash & n;
if (b != runBit) {
runBit = b;
lastRun = p;
}
}
if (runBit == 0) {
ln = lastRun;
hn = null;
}
else {
hn = lastRun;
ln = null;
}
for (Node<K,V> p = f; p != lastRun; p = p.next) {
int ph = p.hash; K pk = p.key; V pv = p.val;
if ((ph & n) == 0)
ln = new Node<K,V>(ph, pk, pv, ln);
else
hn = new Node<K,V>(ph, pk, pv, hn);
}
// 在nextTable i 位置處插上鍊表
setTabAt(nextTab, i, ln);
// 在nextTable i + n 位置處插上鍊表
setTabAt(nextTab, i + n, hn);
// 在table i 位置處插上ForwardingNode 表示該節點已經處理過了
setTabAt(tab, i, fwd);
// advance = true 可以執行--i動作，遍歷節點
advance = true;
}
// 如果是TreeBin，則按照紅黑樹進行處理，處理邏輯與上面一致
else if (f instanceof TreeBin) {
TreeBin<K,V> t = (TreeBin<K,V>)f;
TreeNode<K,V> lo = null, loTail = null;
TreeNode<K,V> hi = null, hiTail = null;
int lc = 0, hc = 0;
for (Node<K,V> e = t.first; e != null; e = e.next) {
int h = e.hash;
TreeNode<K,V> p = new TreeNode<K,V>
(h, e.key, e.val, null, null);
if ((h & n) == 0) {
if ((p.prev = loTail) == null)
lo = p;
else
loTail.next = p;
loTail = p;
++lc;
}
else {
if ((p.prev = hiTail) == null)
hi = p;
else
hiTail.next = p;
hiTail = p;
++hc;
}
}
// 擴容後樹節點個數若<=6，將樹轉鏈表
ln = (lc <= UNTREEIFY_THRESHOLD) ? untreeify(lo) :
(hc != 0) ? new TreeBin<K,V>(lo) : t;
hn = (hc <= UNTREEIFY_THRESHOLD) ? untreeify(hi) :
(lc != 0) ? new TreeBin<K,V>(hi) : t;
setTabAt(nextTab, i, ln);
setTabAt(nextTab, i + n, hn);
setTabAt(tab, i, fwd);
advance = true;
}
}
}
}
}
}
4.get方法：
public V get(Object key) {
Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
int h = spread(key.hashCode()); //計算兩次hash
if ((tab = table) != null && (n = tab.length) > 0 &&
(e = tabAt(tab, (n - 1) & h)) != null) {//讀取首節點的Node元素
if ((eh = e.hash) == h) { //如果該節點就是首節點就返回
if ((ek = e.key) == key || (ek != null && key.equals(ek)))
return e.val;
}
//hash值爲負值表示正在擴容，這個時候查的是ForwardingNode的find方法來定位到nextTable來
//查找，查找到就返回
else if (eh < 0)
return (p = e.find(h, key)) != null ? p.val : null;
while ((e = e.next) != null) {//既不是首節點也不是ForwardingNode，那就往下遍歷
if (e.hash == h &&
((ek = e.key) == key || (ek != null && key.equals(ek))))
return e.val;
}
}
return null;
}
- 計算hash值，定位到該table索引位置，如果是首節點符合就返回
- 如果遇到擴容的時候，會調用標誌正在擴容節點ForwardingNode的find方法，查找該節點，匹配就返回
- 以上都不符合的話，就往下遍歷節點，匹配就返回，否則最後就返回null
5.size操作：元素總數 = baseCount + sum(CounterCell)
public int size() {
long n = sumCount();
return ((n < 0L) ? 0 :
(n > (long)Integer.MAX_VALUE) ? Integer.MAX_VALUE :
(int)n);
}
final long sumCount() {
CounterCell[] as = counterCells; CounterCell a; //變化的數量
long sum = baseCount;
if (as != null) {
for (int i = 0; i < as.length; ++i) {
if ((a = as[i]) != null)
sum += a.value;
}
}
return sum;
}