上一篇介紹了HashMap的數據結構：數組+單鏈表（jdk 1.8，當鏈表長度達到8後，鏈表將會被轉換爲紅黑樹結構）。日常開發中我們經常使用，隨着業務規模、場景的不斷複雜發展，多線程開發越來越多的進入到我們日常開發中，那麼問題就來了，HashMap是線程安全的嗎？答案是否定的，保證HashMap的線程安全需要我們開發中自行維護。那麼有沒有線程安全的集合框架呢？答案是肯定的，java.util包下的HashTab類，就是一種線程安全的Map容器。
Hashtabe
爲了更快速的理解Hashtabe，接下來就結合HashMap做下對比，幫助我們更直觀的認識。
1、Hashtabe默認的容量是11，而HashMap是16
2、Hashtabe數組表是一旦創建就構造，屬於餓漢模式，而HashMap是在第一次put時的resize構造
3、Hashtabe數據結構是數組+單向鏈表，而HashMap則是數組+單向鏈表+紅黑樹
4、Hashtabe中鏈表Node節點採用頭插法，而HashMap則是採用尾插法
5、Hashtabe通過對put、get、remove、size等方法添加synchronized關鍵字保證線程安全，而HashMap本身並沒有保證線程安全的相關處理，需要業務使用時自行保障
6、Hashtabe的鍵值均不能爲null，而HashMap支持鍵值爲null
下面我們看一下Hashtabe的源碼，驗證一下我們上面提到的內容，首先我們看一下構造方法：
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]; // 擴容閾值 = 數組容量 * 負載係數；最大值爲：0x7fffffff - 8 + 1 threshold = (int)Math.min(initialCapacity * loadFactor, MAX_ARRAY_SIZE + 1); } public Hashtable(int initialCapacity) { this(initialCapacity, 0.75f); } public Hashtable() { this(11, 0.75f); } public Hashtable(Map<? extends K, ? extends V> t) { this(Math.max(2*t.size(), 11), 0.75f); putAll(t); }
通過源碼我們可以看到，無參構造方法中，系統默認爲我們定義了數組的容量和負載係數，並且在調用構造方法時，系統會默認爲我們創建初始數組，這裏和HashMap有所不同，大家可以做下對比，便於更好的記憶。
下面我們以put方法爲例，分析一下上面我們提到的幾個點
public synchronized V put(K key, V value) { // 檢查值value是否爲空 if (value == null) { throw new NullPointerException(); } // 檢查鍵是否存在於hash表中 Entry<?,?> tab[] = table; // 鍵不能爲空，否則會導致空指針 int hash = key.hashCode(); // 這裏獲取key數組下標有別於HashMap int index = (hash & 0x7FFFFFFF) % tab.length; @SuppressWarnings("unchecked") Entry<K,V> entry = (Entry<K,V>)tab[index]; // 遍歷數組當前節點的單鏈表查詢鍵是否已存在 for(; entry != null ; entry = entry.next) { if ((entry.hash == hash) && entry.key.equals(key)) { V old = entry.value; // 鍵值存在直接更新，並返回原鍵值 entry.value = value; return old; } } // 當鍵不存在時，將鍵值插入指定鏈表中 addEntry(hash, key, value, index); return null; } private void addEntry(int hash, K key, V value, int index) { modCount++; // 檢查數組長度是否達到閾值，達到閾值對數組進行擴容 Entry<?,?> tab[] = table; if (count >= threshold) { // Rehash the table if the threshold is exceeded rehash(); tab = table; hash = key.hashCode(); // 數組擴容後，以新數組長度計算鍵的數組下標 index = (hash & 0x7FFFFFFF) % tab.length; } // 以鍵值創建新的Node節點，將數組該位置的原頭節點，設置爲新節點的next @SuppressWarnings("unchecked") Entry<K,V> e = (Entry<K,V>) tab[index]; tab[index] = new Entry<>(hash, key, value, e); count++; } protected void rehash() { int oldCapacity = table.length; Entry<?,?>[] oldMap = table; // 創建一個數組容量擴大2倍 + 1的新數組 int newCapacity = (oldCapacity << 1) + 1; if (newCapacity - MAX_ARRAY_SIZE > 0) { if (oldCapacity == MAX_ARRAY_SIZE) // Keep running with MAX_ARRAY_SIZE buckets return; newCapacity = MAX_ARRAY_SIZE; } Entry<?,?>[] newMap = new Entry<?,?>[newCapacity]; modCount++; // 更新新數組的閾值 threshold = (int)Math.min(newCapacity * loadFactor, MAX_ARRAY_SIZE + 1); table = newMap; // 循環遍歷進行數組數據遷移 for (int i = oldCapacity ; i-- > 0 ;) { for (Entry<K,V> old = (Entry<K,V>)oldMap[i] ; old != null ; ) { Entry<K,V> e = old; old = old.next; int index = (e.hash & 0x7FFFFFFF) % newCapacity; e.next = (Entry<K,V>)newMap[index]; newMap[index] = e; } } }
到這裏大家應該對於Hashtable已經有了一個清晰的認識了，這裏提到synchronized關鍵字，我們知道synchronized有兩個維度：1、類維度加鎖；2、對象維度加鎖，Hashtabe採用的是什麼維度呢？答案是對象維度加鎖。這樣做有產生什麼樣的問題呢？這要簡單聊一下多線程的使用場景，我們爲什麼要用多線程？我們知道單線程下我們的任務是串行執行的，對於多CPU系統中，無法發揮多核心的優勢，使用多線程將一個任務拆分爲並行的多個任務，在多CPU系統並行執行任務，從而提高任務的執行效率。那麼問題就來了，Hashtabe通過對象維度加鎖，當存在多個線程並行操作時，就會存在鎖競爭，這也是爲什麼常說Hashtable慢的原因所在。synchronized關鍵字加鎖是對整個對象進行加鎖，也就是說在進行put等修改Hash表的操作時，鎖住了整個Hash表，從而使得其表現的效率低下。
Hashtable雖然保證了線程安全，但是在多線程下的執行效率存在問題，那麼有沒有更好的Map容器呢？答案是肯定的，java.util.concurrent（juc）包下的ConcurrentHashMap就爲我們提供了高效且線程安全的Map容器解決方案。
ConcurrentHashMap
ConcurrentHashMap - JDK 1.7
在JDK1.5~1.7版本，Java使用了分段鎖機制實現ConcurrentHashMap.
簡而言之，ConcurrentHashMap在對象中保存了一個Segment數組，即將整個Hash表劃分爲多個分段；而每個Segment元素，即每個分段則類似於一個Hashtable；這樣，在執行put操作時首先根據hash算法定位到元素屬於哪個Segment，然後對該Segment加鎖即可。因此，ConcurrentHashMap在多線程併發編程中可是實現多線程put操作。接下來分析JDK1.7版本中ConcurrentHashMap的實現原理。
數據結構
整個 ConcurrentHashMap 由一個個 Segment 組成，Segment 代表”部分“或”一段“的意思，所以很多地方都會將其描述爲分段鎖。注意，行文中，我很多地方用了“槽”來代表一個 segment。
簡單理解就是，ConcurrentHashMap 是一個 Segment 數組，Segment 通過繼承 ReentrantLock 來進行加鎖，所以每次需要加鎖的操作鎖住的是一個 segment，這樣只要保證每個 Segment 是線程安全的，也就實現了全局的線程安全。
concurrencyLevel: 並行級別、併發數、Segment 數，怎麼翻譯不重要，理解它。默認是 16，也就是說 ConcurrentHashMap 有 16 個 Segments，所以理論上，這個時候，最多可以同時支持 16 個線程併發寫，只要它們的操作分別分佈在不同的 Segment 上。這個值可以在初始化的時候設置爲其他值，但是一旦初始化以後，它是不可以擴容的。
再具體到每個 Segment 內部，其實每個 Segment 很像之前介紹的 HashMap，不過它要保證線程安全，所以處理起來要麻煩些。
初始化
-
initialCapacity: 初始容量，這個值指的是整個 ConcurrentHashMap 的初始容量，實際操作的時候需要平均分給每個 Segment。
-
loadFactor: 負載因子，之前我們說了，Segment 數組不可以擴容，所以這個負載因子是給每個 Segment 內部使用的。
public ConcurrentHashMap(int initialCapacity, float loadFactor, int concurrencyLevel) { if (!(loadFactor > 0) || initialCapacity < 0 || concurrencyLevel <= 0) throw new IllegalArgumentException();
// MAX_SEGMENTS = 1 << 16 if (concurrencyLevel > MAX_SEGMENTS) concurrencyLevel = MAX_SEGMENTS; int sshift = 0; int ssize = 1; // 計算並行級別 ssize，因爲要保持並行級別是 2 的 n 次方 while (ssize < concurrencyLevel) { ++sshift; ssize <<= 1; } // 我們這裏先不要那麼燒腦，用默認值，concurrencyLevel 爲 16，sshift 爲 4 // 那麼計算出 segmentShift 爲 28，segmentMask 爲 15，後面會用到這兩個值 this.segmentShift = 32 - sshift; this.segmentMask = ssize - 1;
// MAXIMUM_CAPACITY = 1 << 30 if (initialCapacity > MAXIMUM_CAPACITY) initialCapacity = MAXIMUM_CAPACITY; // initialCapacity 是設置整個 map 初始的大小， // 這裏根據 initialCapacity 計算 Segment 數組中每個位置可以分到的大小 // 如 initialCapacity 爲 64，那麼每個 Segment 或稱之爲"槽"可以分到 4 個 int c = initialCapacity / ssize; if (c * ssize < initialCapacity) ++c; // 默認 MIN_SEGMENT_TABLE_CAPACITY 是 2，這個值也是有講究的，因爲這樣的話，對於具體的槽上， // 插入一個元素不至於擴容，插入第二個的時候纔會擴容 int cap = MIN_SEGMENT_TABLE_CAPACITY; while (cap < c) cap <<= 1; // 創建 Segment 數組， // 並創建數組的第一個元素 segment[0] Segment<K,V> s0 = new Segment<K,V>(loadFactor, (int)(cap * loadFactor), (HashEntry<K,V>[])new HashEntry[cap]); Segment<K,V>[] ss = (Segment<K,V>[])new Segment[ssize]; // 往數組寫入 segment[0] UNSAFE.putOrderedObject(ss, SBASE, s0); // ordered write of segments[0] this.segments = ss; }
初始化完成，我們得到了一個 Segment 數組。
我們就當是用 new ConcurrentHashMap() 無參構造函數進行初始化的，那麼初始化完成後:
- Segment 數組長度爲 16，不可以擴容
- Segment[i] 的默認大小爲 2，負載因子是 0.75，得出初始閾值爲 1.5，也就是以後插入第一個元素不會觸發擴容，插入第二個會進行第一次擴容
- 這裏初始化了 segment[0]，其他位置還是 null，至於爲什麼要初始化 segment[0]，後面的代碼會介紹
- 當前 segmentShift 的值爲 32 - 4 = 28，segmentMask 爲 16 - 1 = 15，姑且把它們簡單翻譯爲移位數和掩碼，這兩個值馬上就會用到
put 過程分析
我們先看 put 的主流程，對於其中的一些關鍵細節操作，後面會進行詳細介紹。
public V put(K key, V value) { Segment<K,V> s; if (value == null) throw new NullPointerException(); // 1. 計算 key 的 hash 值 int hash = hash(key); // 2. 根據 hash 值找到 Segment 數組中的位置 j // hash 是 32 位，無符號右移 segmentShift(28) 位，剩下高 4 位， // 然後和 segmentMask(15) 做一次與操作，也就是說 j 是 hash 值的高 4 位，也就是槽的數組下標 int j = (hash >>> segmentShift) & segmentMask; // 剛剛說了，初始化的時候初始化了 segment[0]，但是其他位置還是 null， // ensureSegment(j) 對 segment[j] 進行初始化 if ((s = (Segment<K,V>)UNSAFE.getObject // nonvolatile; recheck (segments, (j << SSHIFT) + SBASE)) == null) // in ensureSegment s = ensureSegment(j); // 3. 插入新值到 槽 s 中 return s.put(key, hash, value, false); } private int hash(Object k) { int h = hashSeed; if ((0 != h) && (k instanceof String)) { return sun.misc.Hashing.stringHash32((String) k); } h ^= k.hashCode(); // Spread bits to regularize both segment and index locations, // using variant of single-word Wang/Jenkins hash. h += (h << 15) ^ 0xffffcd7d; h ^= (h >>> 10); h += (h << 3); h ^= (h >>> 6); h += (h << 2) + (h << 14); return h ^ (h >>> 16); }
第一層很簡單，根據 hash 值很快就能找到相應的 Segment，之後就是 Segment 內部的 put 操作了。
Segment 內部是由 數組+鏈表 組成的。
final V put(K key, int hash, V value, boolean onlyIfAbsent) { // 在往該 segment 寫入前，需要先獲取該 segment 的獨佔鎖 // 先看主流程，後面還會具體介紹這部分內容 HashEntry<K,V> node = tryLock() ? null : scanAndLockForPut(key, hash, value); V oldValue; try { // 這個是 segment 內部的數組 HashEntry<K,V>[] tab = table; // 再利用 hash 值，求應該放置的數組下標 int index = (tab.length - 1) & hash; // first 是數組該位置處的鏈表的表頭 HashEntry<K,V> first = entryAt(tab, index); // 下面這串 for 循環雖然很長，不過也很好理解，想想該位置沒有任何元素和已經存在一個鏈表這兩種情況 for (HashEntry<K,V> e = first;;) { 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 { // node 到底是不是 null，這個要看獲取鎖的過程，不過和這裏都沒有關係。 // 如果不爲 null，那就直接將它設置爲鏈表表頭；如果是null，初始化並設置爲鏈表表頭。 if (node != null) node.setNext(first); else node = new HashEntry<K,V>(hash, key, value, first); int c = count + 1; // 如果超過了該 segment 的閾值，這個 segment 需要擴容 if (c > threshold && tab.length < MAXIMUM_CAPACITY) rehash(node); // 擴容後面也會具體分析 else // 沒有達到閾值，將 node 放到數組 tab 的 index 位置， // 其實就是將新的節點設置成原鏈表的表頭 setEntryAt(tab, index, node); ++modCount; count = c; oldValue = null; break; } } } finally { // 解鎖 unlock(); } return oldValue; } /** * 僅當該鎖沒有被其他線程持有時才獲取該鎖的調用 */ public boolean ReentrantLock.tryLock() { return sync.nonfairTryAcquire(1); }
整體流程還是比較簡單的，由於有獨佔鎖的保護，所以 segment 內部的操作並不複雜。至於這裏面的併發問題，我們稍後再進行介紹。
到這裏 put 操作就結束了，接下來，我們說一說其中幾步關鍵的操作。
初始化槽: ensureSegment
ConcurrentHashMap 初始化的時候會初始化第一個槽 segment[0]，對於其他槽來說，在插入第一個值的時候進行初始化。
這裏需要考慮併發，因爲很可能會有多個線程同時進來初始化同一個槽 segment[k]，不過只要有一個成功了就可以。
private Segment<K,V> ensureSegment(int k) { final Segment<K,V>[] ss = this.segments; long u = (k << SSHIFT) + SBASE;
Segment<K,V> seg; if ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u)) == null) { // 這裏看到爲什麼之前要初始化 segment[0] 了， // 使用當前 segment[0] 處的數組長度和負載因子來初始化 segment[k] // 爲什麼要用“當前”，因爲 segment[0] 可能早就擴容過了 Segment<K,V> proto = ss[0]; int cap = proto.table.length; float lf = proto.loadFactor; int threshold = (int)(cap * lf); // 初始化 segment[k] 內部的數組 HashEntry<K,V>[] tab = (HashEntry<K,V>[])new HashEntry[cap]; if ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u)) == null) { // 再次檢查一遍該槽是否被其他線程初始化了。 Segment<K,V> s = new Segment<K,V>(lf, threshold, tab); // 使用 while 循環，內部用 CAS，當前線程成功設值或其他線程成功設值後，退出 while ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u)) == null) { if (UNSAFE.compareAndSwapObject(ss, u, null, seg = s)) break; } } } return seg; }
總的來說，ensureSegment(int k) 比較簡單，對於併發操作使用 CAS 進行控制。
獲取寫入鎖: scanAndLockForPut
前面我們看到，在往某個 segment 中 put 的時候，首先會調用 node = tryLock() ? null : scanAndLockForPut(key, hash, value)，也就是說先進行一次 tryLock() 快速獲取該 segment 的獨佔鎖，如果失敗，那麼進入到 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; // 循環獲取鎖 while (!tryLock()) { HashEntry<K,V> f; // to recheck first below if (retries < 0) { if (e == null) { if (node == null) // speculatively create node // 進到這裏說明數組該位置的鏈表是空的，沒有任何元素 // 當然，進到這裏的另一個原因是 tryLock() 失敗，所以該槽存在併發，不一定是該位置 node = new HashEntry<K,V>(hash, key, value, null); retries = 0; } else if (key.equals(e.key)) retries = 0; else // 順着鏈表往下走 e = e.next; } // 重試次數如果超過 MAX_SCAN_RETRIES(單核1多核64)，那麼不搶了，進入到阻塞隊列等待鎖 // lock() 是阻塞方法，直到獲取鎖後返回 else if (++retries > MAX_SCAN_RETRIES) { lock(); break; } else if ((retries & 1) == 0 && // 這個時候是有大問題了，那就是有新的元素進到了鏈表，成爲了新的表頭 // 所以這邊的策略是，相當於重新走一遍這個 scanAndLockForPut 方法 (f = entryForHash(this, hash)) != first) { e = first = f; // re-traverse if entry changed retries = -1; } } return node; }
這個方法有兩個出口，一個是 tryLock() 成功了，循環終止，另一個就是重試次數超過了 MAX_SCAN_RETRIES，進到 lock() 方法，此方法會阻塞等待，直到成功拿到獨佔鎖。
這個方法就是看似複雜，但是其實就是做了一件事，那就是獲取該 segment 的獨佔鎖，如果需要的話順便實例化了一下 node。
擴容: rehash
重複一下，segment 數組不能擴容，擴容是 segment 數組某個位置內部的數組 HashEntry<K,V>[] 進行擴容，擴容後，容量爲原來的 2 倍。
首先，我們要回顧一下觸發擴容的地方，put 的時候，如果判斷該值的插入會導致該 segment 的元素個數超過閾值，那麼先進行擴容，再插值，讀者這個時候可以回去 put 方法看一眼。
該方法不需要考慮併發，因爲到這裏的時候，是持有該 segment 的獨佔鎖的。
// 方法參數上的 node 是這次擴容後，需要添加到新的數組中的數據。 private void rehash(HashEntry<K,V> node) { HashEntry<K,V>[] oldTable = table; int oldCapacity = oldTable.length; // 新數組長度 oldCapacity 的 2 倍 int newCapacity = oldCapacity << 1; threshold = (int)(newCapacity * loadFactor);
// 創建新數組 HashEntry<K,V>[] newTable = (HashEntry<K,V>[]) new HashEntry[newCapacity]; // 新的掩碼，如從 16 擴容到 32，那麼 sizeMask 爲 31，對應二進制 ‘000...00011111’ int sizeMask = newCapacity - 1; // 遍歷原數組，老套路，將原數組位置 i 處的鏈表拆分到 新數組位置 i 和 i+oldCap 兩個位置 for (int i = 0; i < oldCapacity ; i++) { // e 是鏈表的第一個元素 HashEntry<K,V> e = oldTable[i]; if (e != null) { HashEntry<K,V> next = e.next; // 計算應該放置在新數組中的位置， // 假設原數組長度爲 16，e 在 oldTable[3] 處，那麼 idx 只可能是 3 或者是 3 + 16 = 19 int idx = e.hash & sizeMask; if (next == null) // 該位置處只有一個元素，那比較好辦 newTable[idx] = e; else { // Reuse consecutive sequence at same slot // e 是鏈表表頭 HashEntry<K,V> lastRun = e; // idx 是當前鏈表的頭結點 e 的新位置 int lastIdx = idx; // 下面這個 for 循環會找到一個 lastRun 節點，這個節點之後的所有元素是將要放到一起的 for (HashEntry<K,V> last = next; last != null; last = last.next) { int k = last.hash & sizeMask; if (k != lastIdx) { lastIdx = k; lastRun = last; } }
// 將 lastRun 及其之後的所有節點組成的這個鏈表放到 lastIdx 這個位置 newTable[lastIdx] = lastRun; // 下面的操作是處理 lastRun 之前的節點， // 這些節點可能分配在另一個鏈表中，也可能分配到上面的那個鏈表中 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); } } } } // 將新來的 node 放到新數組中剛剛的 兩個鏈表之一 的 頭部 int nodeIndex = node.hash & sizeMask; // add the new node node.setNext(newTable[nodeIndex]); newTable[nodeIndex] = node; table = newTable; }
這裏的擴容比之前的 HashMap 要複雜一些，代碼難懂一點。上面有兩個挨着的 for 循環，第一個 for 有什麼用呢?
仔細一看發現，如果沒有第一個 for 循環，也是可以工作的，但是，這個 for 循環下來，如果 lastRun 的後面還有比較多的節點，那麼這次就是值得的。因爲我們只需要克隆 lastRun 前面的節點，後面的一串節點跟着 lastRun 走就是了，不需要做任何操作。
我覺得 Doug Lea 的這個想法也是挺有意思的，不過比較壞的情況就是每次 lastRun 都是鏈表的最後一個元素或者很靠後的元素，那麼這次遍歷就有點浪費了。不過 Doug Lea 也說了，根據統計，如果使用默認的閾值，大約只有 1/6 的節點需要克隆。
get 過程分析
相對於 put 來說，get 真的不要太簡單。
- 計算 hash 值，找到 segment 數組中的具體位置，或我們前面用的“槽”
- 槽中也是一個數組，根據 hash 找到數組中具體的位置
- 到這裏是鏈表了，順着鏈表進行查找即可
public V get(Object key) { Segment<K,V> s; // manually integrate access methods to reduce overhead HashEntry<K,V>[] tab; // 1. hash 值 int h = hash(key); long u = (((h >>> segmentShift) & segmentMask) << SSHIFT) + SBASE;
// 2. 根據 hash 找到對應的 segment if ((s = (Segment<K,V>)UNSAFE.getObjectVolatile(segments, u)) != null && (tab = s.table) != null) {
// 3. 找到segment 內部數組相應位置的鏈表，遍歷 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))) return e.value; } } return null; }
經過上面的分析我們已經知道了ConcurrentHashMap採用的是分段鎖機制來保證線程安全，使用 CAS 進行併發操作控制。對於CAS操作這裏簡單介紹一下
什麼是CAS
CAS的全稱爲Compare-And-Swap，直譯就是對比交換。是一條CPU的原子指令，其作用是讓CPU先進行比較兩個值是否相等，然後原子地更新某個位置的值，經過調查發現，其實現方式是基於硬件平臺的彙編指令，就是說CAS是靠硬件實現的，JVM只是封裝了彙編調用，那些AtomicInteger類便是使用了這些封裝後的接口。簡單解釋：CAS操作需要輸入兩個數值，一箇舊值(期望操作前的值)和一個新值，在操作期間先比較下在舊值有沒有發生變化，如果沒有發生變化，才交換成新值，發生了變化則不交換。
CAS操作是原子性的，所以多線程併發使用CAS更新數據時，可以不使用鎖。JDK中大量使用了CAS來更新數據而防止加鎖(synchronized 重量級鎖)來保持原子更新。
CAS操作
/** * 比較obj的offset處內存位置中的值和期望的值，如果相同則更新。此更新是不可中斷的。 * * @param obj 需要更新的對象 * @param offset obj中整型field的偏移量 * @param expect 希望field中存在的值 * @param update 如果期望值expect與field的當前值相同，設置filed的值爲這個新值 * @return 如果field的值被更改返回true */ public native boolean compareAndSwapInt(Object obj, long offset, int expect, int update);
CAS操作有3個操作數，內存值M，預期值E，新值U，如果M==E，則將內存值修改爲B，否則啥都不做。
public class AtomicReference<V> implements java.io.Serializable { private static final Unsafe unsafe = Unsafe.getUnsafe(); private static final long valueOffset; static { try { /** * JVM的實現可以自由選擇如何實現Java對象的“佈局”，也就是在內存裏Java對象的各個部分放在哪裏，
* 包括對象的實例字段和一些元數據之類。sun.misc.Unsafe裏關於對象字段訪問的方法把對象佈局抽象出來，
* 它提供了objectFieldOffset()方法用於獲取某個字段相對Java對象的“起始地址”的偏移量 */ valueOffset = unsafe.objectFieldOffset (AtomicReference.class.getDeclaredField("value")); } catch (Exception ex) { throw new Error(ex); } } private volatile V value; /** * Gets the current value. * * @return the current value */ public final V get() { return value; } /** * Sets to the given value. * * @param newValue the new value */ public final void set(V newValue) { value = newValue; } /** * Eventually sets to the given value. * * @param newValue the new value * @since 1.6 */ public final void lazySet(V newValue) { unsafe.putOrderedObject(this, valueOffset, newValue); } } public static void putOrderedObject() { AtomicReference atomicReference = new AtomicReference(); atomicReference.set(1); System.out.println("set=" + atomicReference.get()); atomicReference.lazySet(2); System.out.println("lazySet=" + atomicReference.get()); }
ConcurrentHashMap - JDK 1.8
在JDK1.7之前，ConcurrentHashMap是通過分段鎖機制來實現的，所以其最大併發度受Segment的個數限制。因此，在JDK1.8中，ConcurrentHashMap的實現原理摒棄了這種設計，而是選擇了與HashMap類似的數組+鏈表+紅黑樹的方式實現，而加鎖則採用CAS和synchronized實現。
結構上和 Java8 的 HashMap 基本上一樣，不過它要保證線程安全性，所以在源碼上確實要複雜一些。
初始化
// 這構造函數裏，什麼都不幹 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; }
這個初始化方法有點意思，通過提供初始容量，計算了 sizeCtl，sizeCtl = 【 (1.5 * initialCapacity + 1)，然後向上取最近的 2 的 n 次方】。如 initialCapacity 爲 10，那麼得到 sizeCtl 爲 16，如果 initialCapacity 爲 11，得到 sizeCtl 爲 32。
sizeCtl 這個屬性使用的場景很多，不過只要跟着文章的思路來，就不會被它搞暈了。
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();
// 得到 hash 值 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(); // 找該 hash 值對應的數組下標，得到第一個節點 f else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) { // 如果數組該位置爲空， // 用一次 CAS 操作將這個新值放入其中即可，這個 put 操作差不多就結束了，可以拉到最後面了 // 如果 CAS 失敗，那就是有併發操作，進到下一個循環就好了 if (casTabAt(tab, i, null, new Node<K,V>(hash, key, value, null))) break; // no lock when adding to empty bin } // hash 居然可以等於 MOVED，這個需要到後面才能看明白，不過從名字上也能猜到，肯定是因爲在擴容 else if ((fh = f.hash) == MOVED) // 幫助數據遷移，這個等到看完數據遷移部分的介紹後，再理解這個就很簡單了 tab = helpTransfer(tab, f); else {
// 到這裏就是說，f 是該位置的頭結點，而且不爲空 V oldVal = null; // 獲取數組該位置的頭結點的監視器鎖 synchronized (f) { if (tabAt(tab, i) == f) { if (fh >= 0) { // 頭結點的 hash 值大於 0，說明是鏈表 // 用於累加，記錄鏈表的長度 binCount = 1; // 遍歷鏈表 for (Node<K,V> e = f;; ++binCount) { K ek; // 如果發現了"相等"的 key，判斷是否要進行值覆蓋，然後也就可以 break 了 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) { // 判斷是否要將鏈表轉換爲紅黑樹，臨界值和 HashMap 一樣，也是 8 if (binCount >= TREEIFY_THRESHOLD) // 這個方法和 HashMap 中稍微有一點點不同，那就是它不是一定會進行紅黑樹轉換， // 如果當前數組的長度小於 64，那麼會選擇進行數組擴容，而不是轉換爲紅黑樹\ treeifyBin(tab, i); if (oldVal != null) return oldVal; break; } } }
// 待補充 addCount(1L, binCount); return null; }
初始化數組: initTable
這個比較簡單，主要就是初始化一個合適大小的數組，然後會設置 sizeCtl。
初始化方法中的併發問題是通過對 sizeCtl 進行一個 CAS 操作來控制的。
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 // CAS 一下，將 sizeCtl 設置爲 -1，代表搶到了鎖 else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) { try { if ((tab = table) == null || tab.length == 0) { // DEFAULT_CAPACITY 默認初始容量是 16 int n = (sc > 0) ? sc : DEFAULT_CAPACITY; // 初始化數組，長度爲 16 或初始化時提供的長度 Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n]; // 將這個數組賦值給 table，table 是 volatile 的 table = tab = nt; // 如果 n 爲 16 的話，那麼這裏 sc = 12 // 其實就是 0.75 * n sc = n - (n >>> 2); } } finally { // 設置 sizeCtl 爲 sc，我們就當是 12 吧 sizeCtl = sc; } break; } } return tab; }
鏈表轉紅黑樹: treeifyBin
前面我們在 put 源碼分析也說過，treeifyBin 不一定就會進行紅黑樹轉換，也可能是僅僅做數組擴容。
private final void treeifyBin(Node<K,V>[] tab, int index) { Node<K,V> b; int n, sc; if (tab != null) { // MIN_TREEIFY_CAPACITY 爲 64 // 所以，如果數組長度小於 64 的時候，其實也就是 32 或者 16 或者更小的時候，會進行數組擴容 if ((n = tab.length) < MIN_TREEIFY_CAPACITY) // 嘗試進行數組預擴容 tryPresize(n << 1); // b 是頭結點 else if ((b = tabAt(tab, index)) != null && b.hash >= 0) { // 加鎖 synchronized (b) { if (tabAt(tab, index) == b) { // 下面就是遍歷鏈表，建立一顆紅黑樹 TreeNode<K,V> hd = null, tl = null; for (Node<K,V> e = b; e != null; e = e.next) { TreeNode<K,V> p = new TreeNode<K,V>(e.hash, e.key, e.val, null, null); if ((p.prev = tl) == null) hd = p; else tl.next = p; tl = p; } // 將紅黑樹設置到數組相應位置中 setTabAt(tab, index, new TreeBin<K,V>(hd)); } } } } }
預擴容: tryPresize
如果說 Java8 ConcurrentHashMap 的源碼不簡單，那麼說的就是預擴容操作和遷移操作。
這個方法要完完全全看懂還需要看之後的 transfer 方法
這裏的預擴容也是做翻倍擴容的，擴容後數組容量爲原來的 2 倍。
// 首先要說明的是，方法參數 size 傳進來的時候就已經翻了倍了 private final void tryPresize(int size) { // c: size 的 1.5 倍，再加 1，再往上取最近的 2 的 n 次方。 int c = (size >= (MAXIMUM_CAPACITY >>> 1)) ? MAXIMUM_CAPACITY : tableSizeFor(size + (size >>> 1) + 1);
int sc; while ((sc = sizeCtl) >= 0) { Node<K,V>[] tab = table; int n; // 這個 if 分支和之前說的初始化數組的代碼基本上是一樣的，在這裏，我們可以不用管這塊代碼 if (tab == null || (n = tab.length) == 0) { n = (sc > c) ? sc : c; if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) { try { if (table == tab) { @SuppressWarnings("unchecked") Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n]; table = nt; sc = n - (n >>> 2); // 0.75 * n } } finally { sizeCtl = sc; } } }
else if (c <= sc || n >= MAXIMUM_CAPACITY) break;
else if (tab == table) { // 我沒看懂 rs 的真正含義是什麼，不過也關係不大 int rs = resizeStamp(n); if (sc < 0) { Node<K,V>[] nt; if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 || sc == rs + MAX_RESIZERS || (nt = nextTable) == null || transferIndex <= 0) break;
// 2. 用 CAS 將 sizeCtl 加 1，然後執行 transfer 方法 // 此時 nextTab 不爲 null if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1)) transfer(tab, nt); }
// 1. 將 sizeCtl 設置爲 (rs << RESIZE_STAMP_SHIFT) + 2) // 我是沒看懂這個值真正的意義是什麼? 不過可以計算出來的是，結果是一個比較大的負數 // 調用 transfer 方法，此時 nextTab 參數爲 null else if (U.compareAndSwapInt(this, SIZECTL, sc, (rs << RESIZE_STAMP_SHIFT) + 2)) transfer(tab, null); } } }
這個方法的核心在於 sizeCtl 值的操作，首先將其設置爲一個負數，然後執行 transfer(tab, null)，再下一個循環將 sizeCtl 加 1，並執行 transfer(tab, nt)，之後可能是繼續 sizeCtl 加 1，並執行 transfer(tab, nt)。
所以，可能的操作就是執行 1 次 transfer(tab, null) + 多次 transfer(tab, nt)，這裏怎麼結束循環的需要看完 transfer 源碼才清楚。
數據遷移: transfer
下面這個方法有點長，將原來的 tab 數組的元素遷移到新的 nextTab 數組中。
雖然我們之前說的 tryPresize 方法中多次調用 transfer 不涉及多線程，但是這個 transfer 方法可以在其他地方被調用，典型地，我們之前在說 put 方法的時候就說過了，請往上看 put 方法，是不是有個地方調用了 helpTransfer 方法，helpTransfer 方法會調用 transfer 方法的。
此方法支持多線程執行，外圍調用此方法的時候，會保證第一個發起數據遷移的線程，nextTab 參數爲 null，之後再調用此方法的時候，nextTab 不會爲 null。
閱讀源碼之前，先要理解併發操作的機制。原數組長度爲 n，所以我們有 n 個遷移任務，讓每個線程每次負責一個小任務是最簡單的，每做完一個任務再檢測是否有其他沒做完的任務，幫助遷移就可以了，而 Doug Lea 使用了一個 stride，簡單理解就是步長，每個線程每次負責遷移其中的一部分，如每次遷移 16 個小任務。所以，我們就需要一個全局的調度者來安排哪個線程執行哪幾個任務，這個就是屬性 transferIndex 的作用。
第一個發起數據遷移的線程會將 transferIndex 指向原數組最後的位置，然後從後往前的 stride 個任務屬於第一個線程，然後將 transferIndex 指向新的位置，再往前的 stride 個任務屬於第二個線程，依此類推。當然，這裏說的第二個線程不是真的一定指代了第二個線程，也可以是同一個線程，這個讀者應該能理解吧。其實就是將一個大的遷移任務分爲了一個個任務包。
private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) { int n = tab.length, stride; // stride 在單核下直接等於 n，多核模式下爲 (n>>>3)/NCPU，最小值是 16 // stride 可以理解爲”步長“，有 n 個位置是需要進行遷移的， // 將這 n 個任務分爲多個任務包，每個任務包有 stride 個任務 if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE) stride = MIN_TRANSFER_STRIDE; // 如果 nextTab 爲 null，先進行一次初始化 // 前面我們說了，外圍會保證第一個發起遷移的線程調用此方法時，參數 nextTab 爲 null // 之後參與遷移的線程調用此方法時，nextTab 不會爲 null if (nextTab == null) { try { // 容量翻倍 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 是 ConcurrentHashMap 中的屬性 nextTable = nextTab; // transferIndex 也是 ConcurrentHashMap 的屬性，用於控制遷移的位置 transferIndex = n; } int nextn = nextTab.length; // ForwardingNode 翻譯過來就是正在被遷移的 Node // 這個構造方法會生成一個Node，key、value 和 next 都爲 null，關鍵是 hash 爲 MOVED // 後面我們會看到，原數組中位置 i 處的節點完成遷移工作後， // 就會將位置 i 處設置爲這個 ForwardingNode，用來告訴其他線程該位置已經處理過了 // 所以它其實相當於是一個標誌。 ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab); // advance 指的是做完了一個位置的遷移工作，可以準備做下一個位置的了 boolean advance = true; boolean finishing = false; // to ensure sweep before committing nextTab /* * 下面這個 for 循環，最難理解的在前面，而要看懂它們，應該先看懂後面的，然後再倒回來看 */ // i 是位置索引，bound 是邊界，注意是從後往前 for (int i = 0, bound = 0;;) { Node<K,V> f; int fh; // 下面這個 while 真的是不好理解 // advance 爲 true 表示可以進行下一個位置的遷移了 // 簡單理解結局: i 指向了 transferIndex，bound 指向了 transferIndex-stride while (advance) { int nextIndex, nextBound;
// --i >= bound : 按一個步長進行數據遷移
// finishing : 結束數據遷移 if (--i >= bound || finishing) advance = false; // 將 transferIndex 值賦給 nextIndex // 這裏 transferIndex 一旦小於等於 0，說明原數組的所有位置都有相應的線程去處理了 else if ((nextIndex = transferIndex) <= 0) { i = -1; advance = false; } else if (U.compareAndSwapInt (this, TRANSFERINDEX, nextIndex, nextBound = (nextIndex > stride ? nextIndex - stride : 0))) { // 看括號中的代碼，nextBound 是這次遷移任務的邊界，注意，是從後往前 bound = nextBound; i = nextIndex - 1; advance = false; } }
if (i < 0 || i >= n || i + n >= nextn) { int sc; if (finishing) { // 所有的遷移操作已經完成 nextTable = null; // 將新的 nextTab 賦值給 table 屬性，完成遷移 table = nextTab; // 重新計算 sizeCtl: n 是原數組長度，所以 sizeCtl 得出的值將是新數組長度的 0.75 倍 sizeCtl = (n << 1) - (n >>> 1); return; } // 之前我們說過，sizeCtl 在遷移前會設置爲 (rs << RESIZE_STAMP_SHIFT) + 2 // 然後，每有一個線程參與遷移就會將 sizeCtl 加 1， // 這裏使用 CAS 操作對 sizeCtl 進行減 1，代表做完了屬於自己的任務 if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) { // 任務結束，方法退出 if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT) return; // 到這裏，說明 (sc - 2) == resizeStamp(n) << RESIZE_STAMP_SHIFT， // 也就是說，所有的遷移任務都做完了，也就會進入到上面的 if(finishing){} 分支了 finishing = advance = true; i = n; // recheck before commit } } // 如果位置 i 處是空的，沒有任何節點，那麼放入剛剛初始化的 ForwardingNode ”空節點“ else if ((f = tabAt(tab, i)) == null) advance = casTabAt(tab, i, null, fwd); // 該位置處是一個 ForwardingNode，代表該位置已經遷移過了 else if ((fh = f.hash) == MOVED) advance = true; // already processed else { // 對數組該位置處的結點加鎖，開始處理數組該位置處的遷移工作 synchronized (f) { if (tabAt(tab, i) == f) { Node<K,V> ln, hn; // 頭結點的 hash 大於 0，說明是鏈表的 Node 節點 if (fh >= 0) { // 下面這一塊和 Java7 中的 ConcurrentHashMap 遷移是差不多的， // 需要將鏈表一分爲二， // 找到原鏈表中的 lastRun，然後 lastRun 及其之後的節點是一起進行遷移的 // lastRun 之前的節點需要進行克隆，然後分到兩個鏈表中 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); } // 其中的一個鏈表放在新數組的位置 i setTabAt(nextTab, i, ln); // 另一個鏈表放在新數組的位置 i+n setTabAt(nextTab, i + n, hn); // 將原數組該位置處設置爲 fwd，代表該位置已經處理完畢， // 其他線程一旦看到該位置的 hash 值爲 MOVED，就不會進行遷移了 setTabAt(tab, i, fwd); // advance 設置爲 true，代表該位置已經遷移完畢 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; 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; } } // 如果一分爲二後，節點數少於 8，那麼將紅黑樹轉換回鏈表 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; // 將 ln 放置在新數組的位置 i setTabAt(nextTab, i, ln); // 將 hn 放置在新數組的位置 i+n setTabAt(nextTab, i + n, hn); // 將原數組該位置處設置爲 fwd，代表該位置已經處理完畢， // 其他線程一旦看到該位置的 hash 值爲 MOVED，就不會進行遷移了 setTabAt(tab, i, fwd); // advance 設置爲 true，代表該位置已經遷移完畢 advance = true; } } } } } }
說到底，transfer 這個方法並沒有實現所有的遷移任務，每次調用這個方法只實現了 transferIndex 往前 stride 個位置的遷移工作，其他的需要由外圍來控制。
這個時候，再回去仔細看 tryPresize 方法可能就會更加清晰一些了。
get 過程分析
get 方法從來都是最簡單的，這裏也不例外:
- 計算 hash 值
- 根據 hash 值找到數組對應位置: (n - 1) & h
- 根據該位置處結點性質進行相應查找
- 如果該位置爲 null，那麼直接返回 null 就可以了
- 如果該位置處的節點剛好就是我們需要的，返回該節點的值即可
- 如果該位置節點的 hash 值小於 0，說明正在擴容，或者是紅黑樹，後面我們再介紹 find 方法
- 如果以上 3 條都不滿足，那就是鏈表，進行遍歷比對即可
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; } // 如果頭結點的 hash 小於 0，說明 正在擴容，或者該位置是紅黑樹 else if (eh < 0) // 參考 ForwardingNode.find(int h, Object k) 和 TreeBin.find(int h, Object k) 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; }
對比總結
HashTable: 使用了synchronized關鍵字對put等操作進行加鎖;ConcurrentHashMap JDK1.7: 使用分段鎖機制實現;ConcurrentHashMap JDK1.8: 則使用數組+鏈表+紅黑樹數據結構和CAS原子操作實現;
參考文章
- https://www.pdai.tech/md/java/thread/java-thread-x-juc-collection-ConcurrentHashMap.html
- https://www.pdai.tech/md/java/thread/java-thread-x-juc-AtomicInteger.html
- https://blog.csdn.net/blogs_broadcast/article/details/80672515