- 前面介紹了jdk1.7和jdk1.8中的HashMap【 JAVA集合：HashMap深度解析（版本對比）】，文章後面分析了HashMap執行緒不安全的原因，那麼作為執行緒安全的Hashtable和ConcurrentHashMap是如何做到執行緒安全的呢？
Hashtable
/**
* @since JDK1.0
*/
public class Hashtable<K,V>
extends Dictionary<K,V>
implements Map<K,V>, Cloneable, java.io.Serializable
複製程式碼- 從上面的jdk1.8中的原始碼就可以看出來，Hashtable是從jdk1.0就有了，而且是執行緒安全的，後來因為Hashtable效率太低才有了HashMap，HashMap為了追求效率，去掉了保障執行緒安全的synchronized關鍵字。
Hashtable和HashMap的主要區別
- 預設大小：Hashtable的預設大小為11，可以設定大於0的值，HashMap的預設大小為16，給定一個值，會初始化為大於給定值的最小的2的倍數值（HashMap見上面連線）。
public Hashtable() {
this(11, 0.75f);
}
public Hashtable(int initialCapacity, float loadFactor) {
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal Load: "+loadFactor);
if (initialCapacity==0)
initialCapacity = 1;
this.loadFactor = loadFactor;
table = new Entry<?,?>[initialCapacity];
threshold = (int)Math.min(initialCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
}
複製程式碼- 擴容：Hashtable擴容為現有容量的2倍+1，HashMap擴容為現有容量的2倍。
int newCapacity = (oldCapacity << 1) + 1;
複製程式碼- Hashtable執行緒安全的原因：
public synchronized int size() {略}
public synchronized boolean isEmpty(){}
public synchronized boolean contains(Object value) {}
public synchronized boolean containsKey(Object key) {}
public synchronized V get(Object key) {}
public synchronized V put(K key, V value) {略}
public synchronized V remove(Object key) {}
public synchronized void putAll(Map<? extends K, ? extends V> t) {}
public synchronized void clear() {}
public synchronized Object clone() {}
public synchronized int hashCode() {}
..........
複製程式碼從原始碼中可以看出，Hashtable的方法上基本上都加上了synchronized關鍵字，而當一個執行緒訪問加了synchronized關鍵字的方法時，會先獲得例項物件的鎖，而其他執行緒就得不到物件的鎖，也就不能訪問加了synchronized關鍵字的方法，這就相當於此執行緒鎖住了Hashtable例項物件的整張表，從而使Hashtable是執行緒安全的。
ConcurrentHashMap
ConcurrentHashMap同樣是執行緒安全的，但是卻比Hashtable效率要高，是如何做到的呢？
簡單說一下sun.misc.Unsafe類，Unsafe類可以直接操作記憶體，並且都是原子操作
- objectFieldOffset方法獲取物件的屬性在記憶體中的偏移量
- putObject(Object var1, long var2, Object var4)方法設定var1物件偏移var2的地址上的值為var4
- getObject(object,offset)方法獲取object物件偏移offset的地址上的屬性的值
- getObjectVolatile(object,offset)方法獲取object物件偏移offset的地址上的屬性的值（用Volatile修飾的屬性）
CAS （原子操作）
cas，Compare and Swap即比較並交換，Unsafe中cas的方法有：
public final native boolean compareAndSwapObject(Object var1, long var2, Object var4, Object var5);
public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);
public final native boolean compareAndSwapLong(Object var1, long var2, long var4, long var6);
複製程式碼compareAndSwapObject方法有4個引數，物件var1，偏移值var2，預期值var4，修改的值var5，如果var1偏移了var2的記憶體地址上的值和var4相等，那麼把記憶體上的值修改為var5並且返回true，否則返回false。
JDK1.7
結構
jdk1.7中，ConcurrentHashMap由一個個segment組成，每個segment中有一個table，table中有連結串列，即把HashMap中的整個table分成了若干個segment，多執行緒操作時對單獨的segment進行加鎖，而不是像HashTable中對整個table進行加鎖，粒度更細，可同時操作的執行緒更多，效率更高。
定義
public class ConcurrentHashMap<K, V> extends AbstractMap<K, V>
implements ConcurrentMap<K, V>, Serializable
複製程式碼ConcurrentHashMap繼承自AbstractMap類，實現了ConcurrentMap和Serializable介面。
成員變數
- 預設初始化大小值16
static final int DEFAULT_INITIAL_CAPACITY = 16;
複製程式碼- 預設負載因子大小0.75
static final float DEFAULT_LOAD_FACTOR = 0.75f;
複製程式碼- 預設分段數量（最大併發執行緒數）
static final int DEFAULT_CONCURRENCY_LEVEL = 16;
複製程式碼- 最大容量
static final int MAXIMUM_CAPACITY = 1 << 30;
複製程式碼- 每個segment分段中表的最小容量
static final int MIN_SEGMENT_TABLE_CAPACITY = 2;
複製程式碼- 最大分段數量
static final int MAX_SEGMENTS = 1 << 16;
複製程式碼- containsValue方法不鎖表的情況下嘗試的次數
static final int RETRIES_BEFORE_LOCK = 2;
複製程式碼segment
segment繼承了ReentrantLock，就有了加鎖和解鎖的方法。
static final class Segment<K,V> extends ReentrantLock implements Serializable {
private static final long serialVersionUID = 2249069246763182397L;
//自旋等待嘗試加鎖次數，單核為1，多核為64，Runtime.getRuntime().availableProcessors()方法獲取CPU核心數
static final int MAX_SCAN_RETRIES =
Runtime.getRuntime().availableProcessors() > 1 ? 64 : 1;
//表，即HashEntry陣列（每個segment中都有一個table）
transient volatile HashEntry<K,V>[] table;
//segment中元素個數
transient int count;
//修改次數
transient int modCount;
//擴容閥值
transient int threshold;
//負載因子
final float loadFactor;
/**
* 建構函式
*/
Segment(float lf, int threshold, HashEntry<K,V>[] tab) {
this.loadFactor = lf;
this.threshold = threshold;
this.table = tab;
}
}
複製程式碼- put方法
final V put(K key, int hash, V value, boolean onlyIfAbsent) {
/**
* 嘗試進行加鎖，如果加鎖失敗，則執行scanAndLockForPut方法，嘗試加鎖一定次數之後呼叫執行緒自中斷方法（自旋等待）。
*/
HashEntry<K,V> node = tryLock() ? null :
scanAndLockForPut(key, hash, value);
V oldValue;
try {
HashEntry<K,V>[] tab = table;
int index = (tab.length - 1) & hash;
HashEntry<K,V> first = entryAt(tab, index);
for (HashEntry<K,V> e = first;;) { //for迴圈查詢key是否存在，如果找到了，替換value值，返回oldValue
if (e != null) {
K k;
if ((k = e.key) == key ||
(e.hash == hash && key.equals(k))) {
oldValue = e.value;
if (!onlyIfAbsent) {
e.value = value;
++modCount;
}
break;
}
e = e.next;
}
else { //如果沒找到，新建HashEntry節點，放到first節點前面
if (node != null) //scanAndLockForPut自旋等待時如果已經新建了節點，設定next值即可，setNext方法實現了延遲寫。
node.setNext(first);
else
node = new HashEntry<K,V>(hash, key, value, first);
int c = count + 1; //元素個數加1，如果超過了閥值，則進行rehash，進行擴容
if (c > threshold && tab.length < MAXIMUM_CAPACITY)
rehash(node);
else
setEntryAt(tab, index, node); //把新建節點放在連結串列的頭位置
++modCount;
count = c;
oldValue = null;
break;
}
}
} finally {
unlock(); //最後釋放鎖
}
return oldValue;
}
複製程式碼- scanAndLockForPut方法，自旋鎖，嘗試加鎖一定次數仍然失敗進行執行緒自中斷，該方法先計算hash值在table中的位置，迴圈該位置上的連結串列查詢key值，如果不存在則新建節點，之後嘗試加鎖MAX_SCAN_RETRIES次，如果一直失敗則掛起當前執行緒。期間如果連結串列頭被修改，則重新開始該過程。
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;
while (!tryLock()) { //獲取鎖失敗時進入迴圈
HashEntry<K,V> f;
if (retries < 0) { //迴圈連結串列，找到key值或者不存在新建節點
if (e == null) {
if (node == null) // speculatively create node
node = new HashEntry<K,V>(hash, key, value, null);
retries = 0;
}
else if (key.equals(e.key)) //如果找到了key值，
retries = 0;
else
e = e.next;
}
/**
* 找到key值或者key值不存在新建節點之後，嘗試加鎖一定次數進入等待狀態
* 嘗試次數，單核為1，多核為64
*/
else if (++retries > MAX_SCAN_RETRIES) {
lock();
break;
}
else if ((retries & 1) == 0 &&
(f = entryForHash(this, hash)) != first) { //如果嘗試加鎖過程中發現連結串列頭變化了，重置retries為-1，重新開始
e = first = f;
retries = -1;
}
}
return node;
}
複製程式碼- rehash方法，對當前table進行擴容操作，大小變為原來的2倍，其中的元素會被重新分配位置，oldTable[idx]上的連結串列上的元素可能會重新hash到newTable[idx]和newTbale[idx+n]的連結串列上,n為oldTable的大小。
private void rehash(HashEntry<K,V> node) {
HashEntry<K,V>[] oldTable = table;
int oldCapacity = oldTable.length;
int newCapacity = oldCapacity << 1; //newTable的大小為oldTable的2被
threshold = (int)(newCapacity * loadFactor);
HashEntry<K,V>[] newTable =
(HashEntry<K,V>[]) new HashEntry[newCapacity];
int sizeMask = newCapacity - 1;
for (int i = 0; i < oldCapacity ; i++) {
HashEntry<K,V> e = oldTable[i];
if (e != null) {
HashEntry<K,V> next = e.next;
int idx = e.hash & sizeMask; //計算節點在newTable中的位置idx
if (next == null) //如果連結串列只有一個節點，直接放到newTable的idx上
newTable[idx] = e;
else {
/**
* 與重新計算每個節點在newTable中的位置並依次進行頭插法插入連結串列頭相比，這裡進行了優化
* 1.計算連結串列中每個節點在newTable中的位置，但是並不立即插入連結串列頭
* 2.記住最後一個與它的上一個節點在新表中位置不同的節點lastRun，即連結串列中此節點之後的節點在newTable中的位置都相同
* 3.把lastRun放到newTable中，它之後的節點會帶過來
* 4.計算lastRun之前的節點在newTable中的位置並依次進行頭插法插入newTable中。
*/
HashEntry<K,V> lastRun = e;
int lastIdx = idx;
for (HashEntry<K,V> last = next;
last != null;
last = last.next) {
int k = last.hash & sizeMask;
if (k != lastIdx) {
lastIdx = k;
lastRun = last;
}
}
newTable[lastIdx] = lastRun;
// Clone remaining nodes
for (HashEntry<K,V> p = e; p != lastRun; p = p.next) {
V v = p.value;
int h = p.hash;
int k = h & sizeMask;
HashEntry<K,V> n = newTable[k];
newTable[k] = new HashEntry<K,V>(h, p.key, v, n);
}
}
}
}
int nodeIndex = node.hash & sizeMask; // 把新節點放入newTable中
node.setNext(newTable[nodeIndex]);
newTable[nodeIndex] = node;
table = newTable;
}
複製程式碼- remove方法，先嚐試獲取鎖，如果加鎖失敗，則scanAndLock自旋等待（和上面的put方法相似），獲取鎖之後，(tab.length - 1) & hash計算刪除節點在table中的下標，如果table中該位置的連結串列不為空，迴圈判斷連結串列中節點是否和刪除節點相等（value為null時，key相等即可，否則key和value均需相等），如果刪除節點存在，設定pre節點的next指標指向next節點即可。
final V remove(Object key, int hash, Object value) {
if (!tryLock()) //嘗試加鎖
scanAndLock(key, hash); //加鎖失敗，則自旋等待
V oldValue = null;
try {
HashEntry<K,V>[] tab = table;
int index = (tab.length - 1) & hash; //計算hash值在table中的下標
HashEntry<K,V> e = entryAt(tab, index);
HashEntry<K,V> pred = null;
while (e != null) {
K k;
HashEntry<K,V> next = e.next;
if ((k = e.key) == key ||
(e.hash == hash && key.equals(k))) {
V v = e.value;
if (value == null || value == v || value.equals(v)) { //key相等時，value為null或者value也相等即為刪除節點
if (pred == null)
setEntryAt(tab, index, next); //如果刪除節點是頭節點，設定頭節點為next節點
else
pred.setNext(next); //否則設定上一個節點的next指標指向next節點
++modCount; //修改次數加1
--count; //節點數量減1
oldValue = v;
}
break;
}
pred = e;
e = next;
}
} finally {
unlock(); //釋放鎖
}
return oldValue;
}
複製程式碼hash方法，用位移及異或運算使k值在segment中的分佈儘量均勻
private int hash(Object k) {
int h = hashSeed;
if ((0 != h) && (k instanceof String)) {
return sun.misc.Hashing.stringHash32((String) k);
}
h ^= k.hashCode();
h += (h << 15) ^ 0xffffcd7d;
h ^= (h >>> 10);
h += (h << 3);
h ^= (h >>> 6);
h += (h << 2) + (h << 14);
return h ^ (h >>> 16);
}
複製程式碼put方法（ConcurrentHashMap的put方法就很簡單了，先計算key值在哪個segment中，然後呼叫segment的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; //計算key落在哪個segment中
if ((s = (Segment<K,V>)UNSAFE.getObject
(segments, (j << SSHIFT) + SBASE)) == null)
s = ensureSegment(j); //如果segment不存在則初始化
return s.put(key, hash, value, false); //呼叫segment的put方法
}
複製程式碼get方法，先計算key落在哪個segment中，如果segment不為null並且table不為null，tab.length - 1) & h計算在table中的下標，迴圈連結串列的節點進行比較，如果key相等或者hash和equals方法相等，則返回value值。
public V get(Object key) {
Segment<K,V> s; // manually integrate access methods to reduce overhead
HashEntry<K,V>[] tab;
int h = hash(key);
long u = (((h >>> segmentShift) & segmentMask) << SSHIFT) + SBASE;
if ((s = (Segment<K,V>)UNSAFE.getObjectVolatile(segments, u)) != null &&
(tab = s.table) != null) {
for (HashEntry<K,V> e = (HashEntry<K,V>) UNSAFE.getObjectVolatile
(tab, ((long)(((tab.length - 1) & h)) << TSHIFT) + TBASE);
e != null; e = e.next) {
K k;
if ((k = e.key) == key || (e.hash == h && key.equals(k))) //如果key相等，或者過載的hash方法和equals方法相等
return e.value;
}
}
return null;
}
複製程式碼remove方法（remova方法有兩個，一個引數只有key，一個引數是key和value，所以segment的remove方法中value為null時，key相等即可）
public V remove(Object key) {
int hash = hash(key); //計算hash值
Segment<K,V> s = segmentForHash(hash); //計算hash值落在哪個segment中
return s == null ? null : s.remove(key, hash, null); //呼叫segment的remove方法
}
/**
* {@inheritDoc}
*
* @throws NullPointerException if the specified key is null
*/
public boolean remove(Object key, Object value) {
int hash = hash(key);
Segment<K,V> s;
return value != null && (s = segmentForHash(hash)) != null &&
s.remove(key, hash, value) != null;
}
複製程式碼JDK1.8
jdk1.8中ConcurrentHashMap有了很大的變化，不再是segment結構，而是使用類似樂觀鎖的方式來達到多執行緒安全的目的。
定義
ConcurrentHashMap繼承了AbstractMap，實現了ConcurrentMap介面。
public class ConcurrentHashMap<K,V> extends AbstractMap<K,V>
implements ConcurrentMap<K,V>, Serializable
複製程式碼常量
- 最大容量
private static final int MAXIMUM_CAPACITY = 1 << 30;
複製程式碼- 預設初始化的容量16，容量必須是2的倍數，最小為1
private static final int DEFAULT_CAPACITY = 16;
複製程式碼- 陣列的最大容量，toArray和相關方法會用到
static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
複製程式碼- 預設分段數量（不再使用，相容老版本）
private static final int DEFAULT_CONCURRENCY_LEVEL = 16;
複製程式碼- 預設負載因子
private static final float LOAD_FACTOR = 0.75f;
複製程式碼- 連結串列轉化為樹的閾值
static final int TREEIFY_THRESHOLD = 8;
複製程式碼- 樹轉化為連結串列的閾值
static final int UNTREEIFY_THRESHOLD = 6;
複製程式碼- 樹結構的最小容量（當table中的其中一個連結串列長度達到8並且table中的節點總數達到64時，會把該連結串列轉化為樹結構，而如果table中的節點數量小於64，不會進行樹結構的轉化，而是對table進行擴容以降低該連結串列的長度。）
static final int MIN_TREEIFY_CAPACITY = 64;
複製程式碼- 擴容時每個核心轉移的間隔數
private static final int MIN_TRANSFER_STRIDE = 16;
複製程式碼private static int RESIZE_STAMP_BITS = 16;
複製程式碼private static final int MAX_RESIZERS = (1 << (32 - RESIZE_STAMP_BITS)) - 1;
複製程式碼private static final int RESIZE_STAMP_SHIFT = 32 - RESIZE_STAMP_BITS;
複製程式碼- 節點的hash值
static final int MOVED = -1; // 表示該節點正在處理中
static final int TREEBIN = -2; // 表示該節點是樹的根節點
static final int RESERVED = -3; // 暫時保留
static final int HASH_BITS = 0x7fffffff; // 正常節點的hash值可用的位數
複製程式碼- CPU的核心數量
static final int NCPU = Runtime.getRuntime().availableProcessors();
複製程式碼屬性
- table表，volatile修飾（一個執行緒修改該屬性時，會立即寫入到主存中，即對其他執行緒立即可見），transient修飾符（序列化時忽略該屬性，即該屬性只存在記憶體中，而不會持久化到磁碟裡）
transient volatile Node<K,V>[] table;
複製程式碼- newTable，進行擴容時會新建該表，其他執行緒發現該表不為空，說明已經有執行緒在進行擴容操作，就會幫助把oldTable中的資料擴容操作到此新表中，一起完成擴容操作。
private transient volatile Node<K,V>[] nextTable;
複製程式碼- baseCount用於計算size的其中一個屬性
private transient volatile long baseCount;
複製程式碼- 控制table初始化和擴容的屬性
- 0 ，初始化值
- -1，表示正在初始化
- -N，表示N-1個執行緒正在一起進行擴容操作
- N ，table為null時，該值表示初始化的大小，table不為null，該值表示下一次擴容的大小
private transient volatile int sizeCtl;
複製程式碼- 擴容時下一個table下標
private transient volatile int transferIndex;
複製程式碼- 擴容和CounterCells時的鎖標識
private transient volatile int cellsBusy;
複製程式碼private transient volatile CounterCell[] counterCells;
複製程式碼private transient KeySetView<K,V> keySet;
private transient ValuesView<K,V> values;
private transient EntrySetView<K,V> entrySet;
複製程式碼節點
- Node節點
static class Node<K,V> implements Map.Entry<K,V> {
final int hash; //hash值
final K key; //key值
volatile V val; //value值
volatile Node<K,V> next; //next節點
Node(int hash, K key, V val, Node<K,V> next) {
this.hash = hash;
this.key = key;
this.val = val;
this.next = next;
}
public final K getKey() { return key; }
public final V getValue() { return val; }
public final int hashCode() { return key.hashCode() ^ val.hashCode(); }
public final String toString(){ return key + "=" + val; }
public final V setValue(V value) {
throw new UnsupportedOperationException();
}
public final boolean equals(Object o) {
Object k, v, u; Map.Entry<?,?> e;
return ((o instanceof Map.Entry) &&
(k = (e = (Map.Entry<?,?>)o).getKey()) != null &&
(v = e.getValue()) != null &&
(k == key || k.equals(key)) &&
(v == (u = val) || v.equals(u)));
}
/**
* Virtualized support for map.get(); overridden in subclasses.
*/
Node<K,V> find(int h, Object k) {
Node<K,V> e = this;
if (k != null) {
do {
K ek;
if (e.hash == h &&
((ek = e.key) == k || (ek != null && k.equals(ek))))
return e;
} while ((e = e.next) != null);
}
return null;
}
}
複製程式碼- ForwardingNode節點（擴容時有執行緒正在操作的連結串列的頭節點的結構），重寫了find方法
static final class ForwardingNode<K,V> extends Node<K,V> {
final Node<K,V>[] nextTable;
ForwardingNode(Node<K,V>[] tab) {
super(MOVED, null, null, null);
this.nextTable = tab;
}
Node<K,V> find(int h, Object k) {
// loop to avoid arbitrarily deep recursion on forwarding nodes
outer: for (Node<K,V>[] tab = nextTable;;) {
Node<K,V> e; int n;
if (k == null || tab == null || (n = tab.length) == 0 ||
(e = tabAt(tab, (n - 1) & h)) == null)
return null;
for (;;) {
int eh; K ek;
if ((eh = e.hash) == h &&
((ek = e.key) == k || (ek != null && k.equals(ek))))
return e;
if (eh < 0) {
if (e instanceof ForwardingNode) {
tab = ((ForwardingNode<K,V>)e).nextTable;
continue outer;
}
else
return e.find(h, k);
}
if ((e = e.next) == null)
return null;
}
}
}
}
複製程式碼建構函式
不同引數的建構函式設定的sizeCtl值並不相同，初始化table時，table的大小也就不同。
public ConcurrentHashMap() {
}
public ConcurrentHashMap(int initialCapacity) {
if (initialCapacity < 0)
throw new IllegalArgumentException();
int cap = ((initialCapacity >= (MAXIMUM_CAPACITY >>> 1)) ?
MAXIMUM_CAPACITY :
tableSizeFor(initialCapacity + (initialCapacity >>> 1) + 1));
this.sizeCtl = cap;
}
public ConcurrentHashMap(Map<? extends K, ? extends V> m) {
this.sizeCtl = DEFAULT_CAPACITY;
putAll(m);
}
public ConcurrentHashMap(int initialCapacity, float loadFactor) {
this(initialCapacity, loadFactor, 1);
}
public ConcurrentHashMap(int initialCapacity,
float loadFactor, int concurrencyLevel) {
if (!(loadFactor > 0.0f) || initialCapacity < 0 || concurrencyLevel <= 0)
throw new IllegalArgumentException();
if (initialCapacity < concurrencyLevel) // Use at least as many bins
initialCapacity = concurrencyLevel; // as estimated threads
long size = (long)(1.0 + (long)initialCapacity / loadFactor);
int cap = (size >= (long)MAXIMUM_CAPACITY) ?
MAXIMUM_CAPACITY : tableSizeFor((int)size);
this.sizeCtl = cap;
}
複製程式碼主要方法
- CAS，jdk1.8中主要用了三種cas操作來保證執行緒安全，這三種方法都是原子性操作。
/**
* tabAt,讀取tab[i]的值
*/
static final <K,V> Node<K,V> tabAt(Node<K,V>[] tab, int i) {
return (Node<K,V>)U.getObjectVolatile(tab, ((long)i << ASHIFT) + ABASE);
}
/**
* casTabAt，如果tab[i]的值等於c，用v替換c並返回true，否則返回false
*/
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);
}
/**
* setTabAt，設定tab[i]=v
*/
static final <K,V> void setTabAt(Node<K,V>[] tab, int i, Node<K,V> v) {
U.putObjectVolatile(tab, ((long)i << ASHIFT) + ABASE, v);
}
複製程式碼- tableSizeFor，計算table的大小，返回大於等於給定整數的最小的2的倍數
private static final int tableSizeFor(int c) {
int n = c - 1;
n |= n >>> 1; //把最前面的1複製到第二位，使下一位也為1。例0100變為0110
n |= n >>> 2; //把上一步的最前面的兩位1複製到下面兩位，使後兩位也為1。例01100010變為01111010
n |= n >>> 4; //...
n |= n >>> 8;
n |= n >>> 16;
return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}
複製程式碼- put方法
public V put(K key, V value) {
return putVal(key, value, false);
}
final V putVal(K key, V value, boolean onlyIfAbsent) {
if (key == null || value == null) throw new NullPointerException(); //ConcurrentHashMap的key和value都不能為null
int hash = spread(key.hashCode());
int binCount = 0;
for (Node<K,V>[] tab = table;;) {
Node<K,V> f; int n, i, fh;
if (tab == null || (n = tab.length) == 0)
tab = initTable(); //如果table為null或者length為0，則進行初始化操作
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) { //如果連結串列頭為null，新建節點
if (casTabAt(tab, i, null,
new Node<K,V>(hash, key, value, null)))
break; //如果多個執行緒同時執行casTabAt，因為是原子性操作，所以只有一個執行緒成功並結束for迴圈，其他執行緒繼續for迴圈
}
else if ((fh = f.hash) == MOVED) //如果連結串列頭節點的hash值為-1，說明table可能正在進行擴容，呼叫helpTransfer方法幫助擴容
tab = helpTransfer(tab, f);
else {
V oldVal = null;
synchronized (f) { //這裡使用synchronized關鍵字，對連結串列頭節點f加鎖，從而實現多執行緒安全
if (tabAt(tab, i) == f) { //加鎖之後需要進行再判斷一次，保證f在加鎖之前沒有被其他執行緒修改
if (fh >= 0) {
binCount = 1; //計算連結串列的長度
for (Node<K,V> e = f;; ++binCount) { //迴圈連結串列，如果找到key則替換，否則新建節點
K ek;
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) { //如果頭節點是樹結構的，則呼叫putTreeVal方法
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) {
if (binCount >= TREEIFY_THRESHOLD) //如果連結串列長度大於等於8，則轉化為樹結構
treeifyBin(tab, i);
if (oldVal != null)
return oldVal;
break;
}
}
}
addCount(1L, binCount); //節點數量+1
return null;
}
static final int spread(int h) {
return (h ^ (h >>> 16)) & HASH_BITS;
}
final Node<K,V>[] helpTransfer(Node<K,V>[] tab, Node<K,V> f) {
Node<K,V>[] nextTab; int sc;
if (tab != null && (f instanceof ForwardingNode) &&
(nextTab = ((ForwardingNode<K,V>)f).nextTable) != null) { //如果table正在進行擴容
int rs = resizeStamp(tab.length); //擴容標識
while (nextTab == nextTable && table == tab &&
(sc = sizeCtl) < 0) {
if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 || //如果狀態變化了，說明擴容結束
sc == rs + MAX_RESIZERS || transferIndex <= 0)
break;
if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1)) { //sizCtl加1，多1個執行緒同時擴容
transfer(tab, nextTab);
break;
}
}
return nextTab;
}
return table;
}
複製程式碼- initTable初始化方法
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(); // 如果有其他執行緒已經開始初始化了，則釋放cpu資源，等待其他執行緒初始化
else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
try { //初始化，設定sizeCtl為-1，表示有執行緒正在初始化
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); //擴容閾值0.75*n
}
} finally {
sizeCtl = sc; //設定sizeCtl為擴容閾值
}
break;
}
}
return tab;
}
複製程式碼- 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());
if ((tab = table) != null && (n = tab.length) > 0 &&
(e = tabAt(tab, (n - 1) & h)) != null) {
if ((eh = e.hash) == h) { //判斷頭節點
if ((ek = e.key) == key || (ek != null && key.equals(ek)))
return e.val;
}
else if (eh < 0) //如果頭節點的hash<0，表明該節點是ForwardingNode節點或者樹節點，呼叫子類的find方法
return (p = e.find(h, key)) != null ? p.val : null;
while ((e = e.next) != null) { //迴圈查詢連結串列中的節點
if (e.hash == h &&
((ek = e.key) == key || (ek != null && key.equals(ek))))
return e.val;
}
}
return null;
}
複製程式碼- transfer擴容方法
private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
int n = tab.length, stride;
if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
stride = MIN_TRANSFER_STRIDE; // 轉移節點時，下標跨越的步幅
if (nextTab == null) { // 初始化nextTab
try {
@SuppressWarnings("unchecked")
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n << 1];
nextTab = nt;
} catch (Throwable ex) { // try to cope with OOME
sizeCtl = Integer.MAX_VALUE;
return;
}
nextTable = nextTab;
transferIndex = n; //從下標n開始轉移節點到新表
}
int nextn = nextTab.length;
ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);
boolean advance = true; //已處理標識
boolean finishing = false; // 結束標識
for (int i = 0, bound = 0;;) {
Node<K,V> f; int fh;
while (advance) { //如果該table[i]處理過，則--i
int nextIndex, nextBound;
if (--i >= bound || finishing)
advance = false;
else if ((nextIndex = transferIndex) <= 0) { //下一個要處理的下標<=0，跳出while迴圈
i = -1;
advance = false;
}
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置空，table變成新表，sizeCtl擴容閾值
nextTable = null;
table = nextTab;
sizeCtl = (n << 1) - (n >>> 1);
return;
}
if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) { //當前執行緒擴容結束，sizeCtl減1
if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT) //如果不等，說明還有其他執行緒沒有結束擴容
return;
finishing = advance = true;
i = n; // recheck before commit
}
}
else if ((f = tabAt(tab, i)) == null)
advance = casTabAt(tab, i, null, fwd);
else if ((fh = f.hash) == MOVED)
advance = true; // 該連結串列已經在處理中
else {
synchronized (f) { //對連結串列頭節點進行加鎖
if (tabAt(tab, i) == f) {
Node<K,V> ln, hn; //ln表示放在下標i的頭節點，hn表示放在下標i+n的頭節點
if (fh >= 0) { //fh>=0表示是Node型別節點
/**
* n是2的倍數
* fh & (n-1)計算hash值在oldTable中的下標i，
* fh & n==0表示在newTable中下標仍為i，
* fh & n==1表示在newTable中的下標為i + n
*/
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) { //如果為0，表示在新表中的下標仍為i
ln = lastRun;
hn = null;
}
else { //否則下標為i+n
hn = lastRun;
ln = null;
}
for (Node<K,V> p = f; p != lastRun; p = p.next) { //把lastRun之前的節點用頭插法插入ln和hn為頭節點的兩條連結串列中
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);
}
setTabAt(nextTab, i, ln); //ln為頭節點的連結串列放入newTable[i]中
setTabAt(nextTab, i + n, hn); //hn為頭節點的連結串列放入newTable[i+n]中
setTabAt(tab, i, fwd); //oldTable[i]修改為ForwardingNode節點，表示已處理
advance = true; //已處理標識
}
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;
/**
* 迴圈連結串列（ConcurrentHashMap中的樹節點也有next指標，也是一條連結串列）
* lo表示將要放到下標i的連結串列的頭節點，loTail用來構建新連結串列，lc表示連結串列節點數量
* ho表示將要放到下標i的連結串列的頭節點，hoTail用來構建新連結串列，hc表示連結串列節點數量
*/
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，則從樹結構轉換為連結串列結構
* 如果大於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;
}
}
}
}
}
}
複製程式碼- remove方法
public V remove(Object key) {
return replaceNode(key, null, null);
}
final V replaceNode(Object key, V value, Object cv) {
int hash = spread(key.hashCode()); //計算hash值
for (Node<K,V>[] tab = table;;) {
Node<K,V> f; int n, i, fh;
if (tab == null || (n = tab.length) == 0 ||
(f = tabAt(tab, i = (n - 1) & hash)) == null) //如果表是空的或者連結串列是空的，結束
break;
else if ((fh = f.hash) == MOVED) //如果連結串列頭節點的hash值是-1，說明正在處理中，如果在擴容，則幫助擴容
tab = helpTransfer(tab, f);
else {
V oldVal = null;
boolean validated = false;
synchronized (f) { //對連結串列頭節點加鎖
if (tabAt(tab, i) == f) {
if (fh >= 0) { //如果是Node節點
validated = true;
for (Node<K,V> e = f, pred = null;;) { //迴圈連結串列查詢key值
K ek;
if (e.hash == hash &&
((ek = e.key) == key ||
(ek != null && key.equals(ek)))) { //如果key值相等
V ev = e.val;
if (cv == null || cv == ev ||
(ev != null && cv.equals(ev))) { //如果給定的value為null或者value也相等
oldVal = ev;
if (value != null) //如果給定value值不為null，替換value
e.val = value;
else if (pred != null) //前一個節點的next指向下一個節點，刪除當前節點
pred.next = e.next;
else
setTabAt(tab, i, e.next); //前一個節點為null，說明是連結串列頭節點，插入頭節點，next指向原頭節點的next
}
break;
}
pred = e;
if ((e = e.next) == null) //如果迴圈連結串列沒找到key，結束
break;
}
}
else if (f instanceof TreeBin) { //如果是樹節點
validated = true;
TreeBin<K,V> t = (TreeBin<K,V>)f;
TreeNode<K,V> r, p;
if ((r = t.root) != null &&
(p = r.findTreeNode(hash, key, null)) != null) { //呼叫樹節點的findTreeNode方法查詢key值
V pv = p.val;
if (cv == null || cv == pv ||
(pv != null && cv.equals(pv))) {
oldVal = pv;
if (value != null)
p.val = value;
else if (t.removeTreeNode(p)) //呼叫樹節點removeTreeNode方法刪除節點，返回true說明節點太少，轉化為連結串列結構
setTabAt(tab, i, untreeify(t.first));
}
}
}
}
}
if (validated) { //如果鎖住頭節點之後執行了刪除操作（有可能加鎖之前，其他執行緒進行了擴容操作，那麼就不會執行刪除節點操作，該值就為false）
if (oldVal != null) {
if (value == null)
addCount(-1L, -1); //count減1
return oldVal;
}
break;
}
}
}
return null;
}
複製程式碼- addCount方法，節點數量加減操作 check<0，不檢查是否擴容，<=1，無競爭情況下才檢查
private final void addCount(long x, int check) {
CounterCell[] as; long b, s;
//如果counterCells不為null或者增加baseCount變數值失敗
if ((as = counterCells) != null ||
!U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) {
CounterCell a; long v; int m;
boolean uncontended = true; //表示無競爭
/**
* 如果as為null或者length為0
* 或者陣列中隨機一個元素為null，ThreadLocalRandom.getProbe()獲取一個隨機值
* 或者CAS加值失敗
* 呼叫fullAddCount增加count值
*/
if (as == null || (m = as.length - 1) < 0 ||
(a = as[ThreadLocalRandom.getProbe() & m]) == null ||
!(uncontended =
U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))) {
fullAddCount(x, uncontended);
return;
}
if (check <= 1)
return;
s = sumCount(); //計算節點數量
}
if (check >= 0) {
Node<K,V>[] tab, nt; int n, sc;
while (s >= (long)(sc = sizeCtl) && (tab = table) != null &&
(n = tab.length) < MAXIMUM_CAPACITY) {
int rs = resizeStamp(n);
if (sc < 0) { //如果小於0，正在擴容或進行初始化
if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
transferIndex <= 0) //如果已結束，推出迴圈
break;
if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1)) //否則幫助擴容，sizeCtl+1表示多一個執行緒進行擴容
transfer(tab, nt);
}
else if (U.compareAndSwapInt(this, SIZECTL, sc,
(rs << RESIZE_STAMP_SHIFT) + 2)) //首次擴容，rs << RESIZE_STAMP_SHIFT) + 2)賦值給sizeCtl
transfer(tab, null);
s = sumCount();
}
}
}
複製程式碼- size方法，計算節點數量，計算baseCount和counterCells的總和
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;
}
複製程式碼總結
- ConcurrentHashMap主要是通過sun.misc.Unsafe類的CAS方法保證了操作的原子性。
- jdk1.7中，ConcurrentHashMap使用segment結構進行分段，segment繼承ReentrantLock實現加鎖，從而保證在多執行緒中是安全的。
- jdk1.8中，ConcurrentHashMap不再使用segment結構，而是使用synchronized關鍵字對table中的連結串列頭節點進行加鎖，粒度更小，從而使同時操作的執行緒數量更多，效率更高。
- jdk1.8中，當連結串列過長時，會轉化為樹結構，提高效率，關於樹結構參考上篇文章TreeMap紅黑樹，大概的思想基本相同。