Java併發系列（9）ConcurrentHashMap源碼分析

時間  2021-05-02
標籤 html node 數組 安全 數據結構 多線程 併發 ssh 函數 高併發 欄目 Java 简体版
原文   原文鏈接

做者： 勞夫子html

cnblogs.com/liuyun1995/p/8631264.htmlnode

咱們知道哈希表是一種很是高效的數據結構，設計優良的哈希函數可使其上的增刪改查操做達到O(1)級別。Java爲咱們提供了一個現成的哈希結構，那就是HashMap類，在前面的文章中我曾經介紹過HashMap類，知道它的全部方法都未進行同步，所以在多線程環境中是不安全的。爲此，Java爲咱們提供了另一個HashTable類，它對於多線程同步的處理很是簡單粗暴，那就是在HashMap的基礎上對其全部方法都使用synchronized關鍵字進行加鎖。數組

這種方法雖然簡單，但致使了一個問題，那就是在同一時間內只能由一個線程去操做哈希表。即便這些線程都只是進行讀操做也必需要排隊，這在競爭激烈的多線程環境中極爲影響性能。本篇介紹的ConcurrentHashMap就是爲了解決這個問題的，它的內部使用分段鎖將鎖進行細粒度化，從而使得多個線程可以同時操做哈希表，這樣極大的提升了性能。安全

下圖是其內部結構的示意圖。數據結構

Java併發系列（9）ConcurrentHashMap源碼分析多線程

  1. ConcurrentHashMap有哪些成員變量？

//默認初始化容量
static final int DEFAULT_INITIAL_CAPACITY = 16;併發

//默認加載因子
static final float DEFAULT_LOAD_FACTOR = 0.75f;ssh

//默認併發級別
static final int DEFAULT_CONCURRENCY_LEVEL = 16;函數

//集合最大容量
static final int MAXIMUM_CAPACITY = 1 << 30;高併發

//分段鎖的最小數量
static final int MIN_SEGMENT_TABLE_CAPACITY = 2;

//分段鎖的最大數量
static final int MAX_SEGMENTS = 1 << 16;

//加鎖前的重試次數
static final int RETRIES_BEFORE_LOCK = 2;

//分段鎖的掩碼值
final int segmentMask;

//分段鎖的移位值
final int segmentShift;

//分段鎖數組
final Segment<K,V>[] segments;
在閱讀完本篇文章以前，相信讀者不能理解這些成員變量的具體含義和做用，不過請讀者們耐心看下去，後面將會在具體場景中一一介紹到這些成員變量的做用。在這裏讀者只需對這些成員變量留個眼熟便可。

可是仍有個別變量是咱們如今須要瞭解的，例如Segment數組表明分段鎖集合，併發級別則表明分段鎖的數量(也意味有多少線程能夠同時操做)，初始化容量表明整個容器的容量，加載因子表明容器元素能夠達到多滿的一種程度。

  1. 分段鎖的內部結構是怎樣的？

//分段鎖
static final class Segment<K,V> extends ReentrantLock implements Serializable {

//自旋最大次數
static final int MAX_SCAN_RETRIES = Runtime.getRuntime().availableProcessors() > 1 ? 64 : 1;
//哈希表
transient volatile HashEntry<K,V>[] table;
//元素總數
transient int count;
//修改次數
transient int modCount;
//元素閥值
transient int threshold;
//加載因子
final float loadFactor;
//省略如下內容
...

}
Segment是ConcurrentHashMap的靜態內部類，能夠看到它繼承自ReentrantLock，所以它在本質上是一個鎖。它在內部持有一個HashEntry數組(哈希表)，而且保證全部對該數組的增刪改查方法都是線程安全的，具體是怎樣實現的後面會講到。

全部對ConcurrentHashMap的增刪改查操做均可以委託Segment來進行，所以ConcurrentHashMap可以保證在多線程環境下是安全的。又由於不一樣的Segment是不一樣的鎖，因此多線程能夠同時操做不一樣的Segment，也就意味着多線程能夠同時操做ConcurrentHashMap，這樣就能避免HashTable的缺陷，從而極大的提升性能。

  1. ConcurrentHashMap初始化時作了些什麼？

//核心構造器
@SuppressWarnings("unchecked")
public ConcurrentHashMap(int initialCapacity, float loadFactor, int concurrencyLevel) {

if (!(loadFactor > 0) || initialCapacity < 0 || concurrencyLevel <= 0) {
    throw new IllegalArgumentException();
}
//確保併發級別不大於限定值
if (concurrencyLevel > MAX_SEGMENTS) {
    concurrencyLevel = MAX_SEGMENTS;
}
int sshift = 0;
int ssize = 1;
//保證ssize爲2的冪, 且是最接近的大於等於併發級別的數
while (ssize < concurrencyLevel) {
    ++sshift;
    ssize <<= 1;
}
//計算分段鎖的移位值
this.segmentShift = 32 - sshift;
//計算分段鎖的掩碼值
this.segmentMask = ssize - 1;
//總的初始容量不能大於限定值
if (initialCapacity > MAXIMUM_CAPACITY) {
    initialCapacity = MAXIMUM_CAPACITY;
}
//獲取每一個分段鎖的初始容量
int c = initialCapacity / ssize;
//分段鎖容量總和不小於初始總容量
if (c * ssize < initialCapacity) {
    ++c;
}
int cap = MIN_SEGMENT_TABLE_CAPACITY;
//保證cap爲2的冪, 且是最接近的大於等於c的數
while (cap < c) {
    cap <<= 1;
}
//新建一個Segment對象模版
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];
//使用UnSafe給數組第0個元素賦值
UNSAFE.putOrderedObject(ss, SBASE, s0);
this.segments = ss;

}
ConcurrentHashMap有多個構造器，可是上面貼出的是它的核心構造器，其餘構造器都經過調用它來完成初始化。核心構造器須要傳入三個參數，分別是初始容量，加載因子和併發級別。在前面介紹成員變量時咱們能夠知道默認的初始容量爲16，加載因子爲0.75f，併發級別爲16。

如今咱們看到核心構造器的代碼，首先是經過傳入的concurrencyLevel來計算出ssize，ssize是Segment數組的長度，它必須保證是2的冪，這樣就能夠經過hash&ssize-1來計算分段鎖在數組中的下標。

因爲傳入的concurrencyLevel不能保證是2的冪，因此不能直接用它來看成Segment數組的長度，所以咱們要找到一個最接近concurrencyLevel的2的冪，用它來做爲數組的長度。假如如今傳入的concurrencyLevel=15，經過上面代碼能夠計算出ssize=16，sshift=4。接下來立馬能夠算出segmentShift=16，segmentMask=15。注意這裏的segmentShift是分段鎖的移位值，segmentMask是分段鎖的掩碼值，這兩個值是用來計算分段鎖在數組中的下標，在下面咱們會講到。

在算出分段鎖的個數ssize以後，就能夠根據傳入的總容量來計算每一個分段鎖的容量，它的值c = initialCapacity / ssize。分段鎖的容量也就是HashEntry數組的長度，一樣也必須保證是2的冪，而上面算出的c的值不能保證這一點，因此不能直接用c做爲HashEntry數組的長度，須要另外找到一個最接近c的2的冪，將這個值賦給cap，而後用cap來做爲HashEntry數組的長度。如今咱們有了ssize和cap，就能夠新建分段鎖數組Segment[]和元素數組HashEntry[]了。注意，與JDK1.6不一樣是的，在JDK1.7中只新建了Segment數組，並無對它初始化，初始化Segment的操做留到了插入操做時進行。

  1. 經過怎樣的方式來定位鎖和定位元素？

//根據哈希碼獲取分段鎖
@SuppressWarnings("unchecked")
private Segment<K,V> segmentForHash(int h) {

long u = (((h >>> segmentShift) & segmentMask) << SSHIFT) + SBASE;
return (Segment<K,V>) UNSAFE.getObjectVolatile(segments, u);

}

//根據哈希碼獲取元素
@SuppressWarnings("unchecked")
static final <K,V> HashEntry<K,V> entryForHash(Segment<K,V> seg, int h) {

HashEntry<K,V>[] tab;
return (seg == null || (tab = seg.table) == null) ? null :
(HashEntry<K,V>) UNSAFE.getObjectVolatile(tab, ((long)(((tab.length - 1) & h)) << TSHIFT) + TBASE);

}
在JDK1.7中是經過UnSafe來獲取數組元素的，所以這裏比JDK1.6多了些計算數組元素偏移量的代碼，這些代碼咱們暫時不關注，如今咱們只需知道下面這兩點：

經過哈希碼計算分段鎖在數組中的下標：(h >>> segmentShift) & segmentMask。

經過哈希碼計算元素在數組中的下標：(tab.length - 1) & h。

如今咱們假設傳給構造器的兩個參數爲initialCapacity=128, concurrencyLevel=16。根據計算能夠獲得ssize=16, sshift=4，segmentShift=28，segmentMask=15。一樣，算得每一個分段鎖內的HashEntry數組的長度爲8，因此tab.length-1=7。根據這些值，咱們經過下圖來解釋如何根據同一個哈希碼來定位分段鎖和元素。

Java併發系列（9）ConcurrentHashMap源碼分析

能夠看到分段鎖和元素的定位都是經過元素的哈希碼來決定的。定位分段鎖是取哈希碼的高位值(從32位處取起)，定位元素是取的哈希碼的低位值。如今有個問題，它們一個從32位的左端取起，一個從32位的右端取起，那麼會在某個時刻產生衝突嗎？咱們在成員變量裏能夠找到MAXIMUM_CAPACITY = 1 << 30，MAX_SEGMENTS = 1 << 16，這說明定位分段鎖和定位元素使用的總的位數不超過30，而且定位分段鎖使用的位數不超過16，因此至少還隔着2位的空餘，所以是不會產生衝突的。

  1. 查找元素具體是怎樣實現的？

//根據key獲取value
public V get(Object key) {

Segment<K,V> s;
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;
        //根據key和hash找到對應元素後返回value值
        if ((k = e.key) == key || (e.hash == h && key.equals(k))) {
            return e.value;
        }
    }
}
return null;

}
在JDK1.6中分段鎖的get方法是經過下標來訪問數組元素的，而在JDK1.7中是經過UnSafe的getObjectVolatile方法來讀取數組中的元素。爲啥要這樣作？

咱們知道雖然Segment對象持有的HashEntry數組引用是volatile類型的，可是數組內的元素引用不是volatile類型的，所以多線程對數組元素的修改是不安全的，可能會在數組中讀取到還沒有構造完成的對象。

在JDK1.6中是經過第二次加鎖讀取來保證安全的，而JDK1.7中經過UnSafe的getObjectVolatile方法來讀取一樣也是爲了保證這一點。使用getObjectVolatile方法讀取數組元素須要先得到元素在數組中的偏移量，在這裏根據哈希碼計算獲得分段鎖在數組中的偏移量爲u，而後經過偏移量u來嘗試讀取分段鎖。因爲分段鎖數組在構造時沒進行初始化，所以可能讀出來一個空值，因此須要先進行判斷。

在肯定分段鎖和它內部的哈希表都不爲空以後，再經過哈希碼讀取HashEntry數組的元素，根據上面的結構圖能夠看到，這時得到的是鏈表的頭結點。以後再從頭至尾的對鏈表進行遍歷查找，若是找到對應的值就將其返回，不然就返回null。以上就是整個查找元素的過程。

  1. 插入元素具體是怎樣實現的？

//向集合添加鍵值對(若存在則替換)
@SuppressWarnings("unchecked")
public V put(K key, V value) {

Segment<K,V> s;
//傳入的value不能爲空
if (value == null) throw new NullPointerException();
//使用哈希函數計算哈希碼
int hash = hash(key);
//根據哈希碼計算分段鎖的下標
int j = (hash >>> segmentShift) & segmentMask;
//根據下標去嘗試獲取分段鎖
if ((s = (Segment<K,V>)UNSAFE.getObject(segments, (j << SSHIFT) + SBASE)) == null) {
    //得到的分段鎖爲空就去構造一個
    s = ensureSegment(j);
}
//調用分段鎖的put方法
return s.put(key, hash, value, false);

}

//向集合添加鍵值對(不存在才添加)
@SuppressWarnings("unchecked")
public V putIfAbsent(K key, V value) {

Segment<K,V> s;
//傳入的value不能爲空
if (value == null) throw new NullPointerException();
//使用哈希函數計算哈希碼
int hash = hash(key);
//根據哈希碼計算分段鎖的下標
int j = (hash >>> segmentShift) & segmentMask;
//根據下標去嘗試獲取分段鎖
if ((s = (Segment<K,V>)UNSAFE.getObject(segments, (j << SSHIFT) + SBASE)) == null) {
    //得到的分段鎖爲空就去構造一個
    s = ensureSegment(j);
}
//調用分段鎖的put方法
return s.put(key, hash, value, true);

}
ConcurrentHashMap中有兩個添加鍵值對的方法，經過put方法添加時若是存在則會進行覆蓋，經過putIfAbsent方法添加時若是存在則不進行覆蓋，這兩個方法都是調用分段鎖的put方法來完成操做，只是傳入的最後一個參數不一樣而已。

在上面代碼中咱們能夠看到首先是根據key的哈希碼來計算出分段鎖在數組中的下標，而後根據下標使用UnSafe類getObject方法來讀取分段鎖。因爲在構造ConcurrentHashMap時沒有對Segment數組中的元素初始化，因此可能讀到一個空值，這時會先經過ensureSegment方法新建一個分段鎖。獲取到分段鎖以後再調用它的put方法完成添加操做，下面咱們來看看具體是怎樣操做的。

//添加鍵值對
final V put(K key, int hash, V value, boolean onlyIfAbsent) {

//嘗試獲取鎖, 若失敗則進行自旋
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;;) {
        //遍歷鏈表尋找該元素, 找到則進行替換
        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結點插入鏈表頭部
            if (node != null) {
                node.setNext(first);
            } else {
                node = new HashEntry<K,V>(hash, key, value, first);
            }
            //插入結點後將元素老是加1
            int c = count + 1;
            //元素超過閥值則進行擴容
            if (c > threshold && tab.length < MAXIMUM_CAPACITY) {
                rehash(node);
            //不然就將哈希表指定下標替換爲node結點
            } else {
                setEntryAt(tab, index, node);
            }
            ++modCount;
            count = c;
            oldValue = null;
            break;
        }
    }
} finally {
    unlock();
}
return oldValue;

}
爲保證線程安全，分段鎖中的put操做是須要進行加鎖的，因此線程一開始就會去獲取鎖，若是獲取成功就繼續執行，若獲取失敗則調用scanAndLockForPut方法進行自旋，在自旋過程當中會先去掃描哈希表去查找指定的key，若是key不存在就會新建一個HashEntry返回，這樣在獲取到鎖以後就沒必要再去新建了，爲的是在等待鎖的過程當中順便作些事情，不至於白白浪費時間，可見做者的良苦用心。

具體自旋方法咱們後面再細講，如今先把關注點拉回來，線程在成功獲取到鎖以後會根據計算到的下標，獲取指定下標的元素。此時獲取到的是鏈表的頭結點，若是頭結點不爲空就對鏈表進行遍歷查找，找到以後再根據onlyIfAbsent參數的值決定是否進行替換。

若是遍歷沒找到就會新建一個HashEntry指向頭結點，此時若是自旋時建立了HashEntry，則直接將它的next指向當前頭結點，若是自旋時沒有建立就在這裏新建一個HashEntry並指向頭結點。在向鏈表添加元素以後檢查元素總數是否超過閥值，若是超過就調用rehash進行擴容，沒超過的話就直接將數組對應下標的元素引用指向新添加的node。setEntryAt方法內部是經過調用UnSafe的putOrderedObject方法來更改數組元素引用的，這樣就保證了其餘線程在讀取時能夠讀到最新的值。

  1. 刪除元素具體是怎樣實現的？

//刪除指定元素(找到對應元素後直接刪除)
public V remove(Object key) {

//使用哈希函數計算哈希碼
int hash = hash(key);
//根據哈希碼獲取分段鎖的索引
Segment<K,V> s = segmentForHash(hash);
//調用分段鎖的remove方法
return s == null ? null : s.remove(key, hash, null);

}

//刪除指定元素(查找值等於給定值才刪除)
public boolean remove(Object key, Object value) {

//使用哈希函數計算哈希碼
int hash = hash(key);
Segment<K,V> s;
//確保分段鎖不爲空才調用remove方法
return value != null && (s = segmentForHash(hash)) != null && s.remove(key, hash, value) != null;

}
ConcurrentHashMap提供了兩種刪除操做，一種是找到後直接刪除，一種是找到後先比較再刪除。這兩種刪除方法都是先根據key的哈希碼找到對應的分段鎖後，再經過調用分段鎖的remove方法完成刪除操做。下面咱們來看看分段鎖的remove方法。

//刪除指定元素
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;
    //根據下標取得數組元素(鏈表頭結點)
    HashEntry<K,V> e = entryAt(tab, index);
    HashEntry<K,V> pred = null;
    //遍歷鏈表尋找要刪除的元素
    while (e != null) {
        K k;
        //next指向當前結點的後繼結點
        HashEntry<K,V> next = e.next;
        //根據key和hash尋找對應結點
        if ((k = e.key) == key || (e.hash == hash && key.equals(k))) {
            V v = e.value;
            //傳入的value不等於v就跳過, 其餘狀況就進行刪除操做
            if (value == null || value == v || value.equals(v)) {
                //若是pred爲空則表明要刪除的結點爲頭結點
                if (pred == null) {
                    //從新設置鏈表頭結點
                    setEntryAt(tab, index, next);
                } else {
                    //設置pred結點的後繼爲next結點
                    pred.setNext(next);
                }
                ++modCount;
                --count;
                //記錄元素刪除以前的值
                oldValue = v;
            }
            break;
        }
        //若e不是要找的結點就將pred引用指向它
        pred = e;
        //檢查下一個結點
        e = next;
    }
} finally {
    unlock();
}
return oldValue;

}
在刪除分段鎖中的元素時須要先獲取鎖，若是獲取失敗就調用scanAndLock方法進行自旋，若是獲取成功就執行下一步，首先計算數組下標而後經過下標獲取HashEntry數組的元素，這裏得到了鏈表的頭結點，接下來就是對鏈表進行遍歷查找，在此以前先用next指針記錄當前結點的後繼結點，而後對比key和hash看看是不是要找的結點，若是是的話就執行下一個if判斷。

知足value爲空或者value的值等於結點當前值這兩個條件就會進入到if語句中進行刪除操做，不然直接跳過。在if語句中執行刪除操做時會有兩種狀況，若是當前結點爲頭結點則直接將next結點設置爲頭結點，若是當前結點不是頭結點則將pred結點的後繼設置爲next結點。這裏的pred結點表示當前結點的前繼結點，每次在要檢查下一個結點以前就將pred指向當前結點，這就保證了pred結點老是當前結點的前繼結點。

注意，與JDK1.6不一樣，在JDK1.7中HashEntry對象的next變量不是final的，所以這裏能夠經過直接修改next引用的值來刪除元素，因爲next變量是volatile類型的，因此讀線程能夠立刻讀到最新的值。

  1. 替換元素具體是怎樣實現的？

//替換指定元素(CAS操做)
public boolean replace(K key, V oldValue, V newValue) {

//使用哈希函數計算哈希碼
int hash = hash(key);
//保證oldValue和newValue不爲空
if (oldValue == null || newValue == null) throw new NullPointerException();
//根據哈希碼獲取分段鎖的索引
Segment<K,V> s = segmentForHash(hash);
//調用分段鎖的replace方法
return s != null && s.replace(key, hash, oldValue, newValue);

}

//替換元素操做(CAS操做)
final boolean replace(K key, int hash, V oldValue, V newValue) {

//嘗試獲取鎖, 若失敗則進行自旋
if (!tryLock()) {
    scanAndLock(key, hash);
}
boolean replaced = false;
try {
    HashEntry<K,V> e;
    //經過hash直接找到頭結點而後對鏈表遍歷
    for (e = entryForHash(this, hash); e != null; e = e.next) {
        K k;
        //根據key和hash找到要替換的結點
        if ((k = e.key) == key || (e.hash == hash && key.equals(k))) {
            //若是指定的當前值正確則進行替換
            if (oldValue.equals(e.value)) {
                e.value = newValue;
                ++modCount;
                replaced = true;
            }
            //不然不進行任何操做直接返回
            break;
        }
    }
} finally {
    unlock();
}
return replaced;

}
ConcurrentHashMap一樣提供了兩種替換操做，一種是找到後直接替換，另外一種是找到後先比較再替換(CAS操做)。這兩種操做的實現大體是相同的，只是CAS操做在替換前多了一層比較操做，所以咱們只需簡單瞭解其中一種操做便可。

這裏拿CAS操做進行分析，仍是老套路，首先根據key的哈希碼找到對應的分段鎖，而後調用它的replace方法。進入分段鎖中的replace方法後須要先去獲取鎖，若是獲取失敗則進行自旋，若是獲取成功則進行下一步。首先根據hash碼獲取鏈表頭結點，而後根據key和hash進行遍歷查找，找到了對應的元素以後，比較給定的oldValue是不是當前值，若是不是則放棄修改，若是是則用新值進行替換。因爲HashEntry對象的value域是volatile類型的，所以能夠直接替換。

  1. 自旋時具體作了些什麼？

//自旋等待獲取鎖(put操做)
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循環內自旋
while (!tryLock()) {
    HashEntry<K,V> f;
    if (retries < 0) {
        //若是頭結點爲空就新建一個node
        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;
        }
      //retries每次在這加1, 並判斷是否超過最大值
    } else if (++retries > MAX_SCAN_RETRIES) {
        lock();
        break;
      //retries爲偶數時去判斷first有沒有改變
    } else if ((retries & 1) == 0 && (f = entryForHash(this, hash)) != first) {
        e = first = f;
        retries = -1;
    }
}
return node;

}

//自旋等待獲取鎖(remove和replace操做)
private void scanAndLock(Object key, int hash) {

//根據哈希碼獲取鏈表頭結點
HashEntry<K,V> first = entryForHash(this, hash);
HashEntry<K,V> e = first;
int retries = -1;
//在while循環裏自旋
while (!tryLock()) {
    HashEntry<K,V> f;
    if (retries < 0) {
        //遍歷鏈表定位到該結點
        if (e == null || key.equals(e.key)) {
            retries = 0;
        } else {
            e = e.next;
        }
      //retries每次在這加1, 並判斷是否超過最大值
    } else if (++retries > MAX_SCAN_RETRIES) {
        lock();
        break;
      //retries爲偶數時去判斷first有沒有改變
    } else if ((retries & 1) == 0 && (f = entryForHash(this, hash)) != first) {
        e = first = f;
        retries = -1;
    }
}

}
在前面咱們講到過，分段鎖中的put，remove，replace這些操做都會要求先去獲取鎖，只有成功得到鎖以後才能進行下一步操做，若是獲取失敗就會進行自旋。

自旋操做也是在JDK1.7中添加的，爲了不線程頻繁的掛起和喚醒，以此提升併發操做時的性能。在put方法中調用的是scanAndLockForPut，在remove和replace方法中調用的是scanAndLock。這兩種自旋方法大體是相同的，這裏咱們只分析scanAndLockForPut方法。首先仍是先根據hash碼得到鏈表頭結點，以後線程會進入while循環中執行，退出該循環的惟一方式是成功獲取鎖，而在這期間線程不會被掛起。

剛進入循環時retries的值爲-1，這時線程不會立刻再去嘗試獲取鎖，而是先去尋找到key對應的結點(沒找到會新建一個)，而後再將retries設爲0，接下來就會一次次的嘗試獲取鎖，對應retries的值也會每次加1，直到超過最大嘗試次數若是還沒獲取到鎖，就會調用lock方法進行阻塞獲取。在嘗試獲取鎖的期間，還會每隔一次(retries爲偶數)去檢查頭結點是否被改變，若是被改變則將retries重置回-1，而後再重走一遍剛纔的流程。這就是線程自旋時所作的操做，需注意的是若是在自旋時檢測到頭結點已被改變，則會延長線程的自旋時間。

  1. 哈希表擴容時都作了哪些操做？

//再哈希
@SuppressWarnings("unchecked")
private void rehash(HashEntry<K,V> node) {

//獲取舊哈希表的引用
HashEntry<K,V>[] oldTable = table;
//獲取舊哈希表的容量
int oldCapacity = oldTable.length;
//計算新哈希表的容量(爲舊哈希表的2倍)
int newCapacity = oldCapacity << 1;
//計算新的元素閥值
threshold = (int)(newCapacity * loadFactor);
//新建一個HashEntry數組
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;
        //next爲空代表鏈表只有一個結點
        if (next == null) {
            //直接把該結點放到新表中
            newTable[idx] = e;
        }else {
            HashEntry<K,V> lastRun = e;
            int lastIdx = idx;
            //定位lastRun結點, 將lastRun以後的結點直接放到新表中
            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;
            //遍歷在鏈表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);
            }
        }
    }
}
//計算傳入結點在新表中的下標
int nodeIndex = node.hash & sizeMask;
//將傳入結點添加到鏈表頭結點
node.setNext(newTable[nodeIndex]);
//將新表指定下標元素換成傳入結點
newTable[nodeIndex] = node;
//將哈希表引用指向新表
table = newTable;

}
rehash方法在put方法中被調用，咱們知道在put方法時會新建元素並添加到哈希數組中，隨着元素的增多發生哈希衝突的可能性越大，哈希表的性能也會隨之降低。所以每次put操做時都會檢查元素總數是否超過閥值，若是超過則調用rehash方法進行擴容。

由於數組長度一旦肯定則不能再被改變，所以須要新建一個數組來替換原先的數組。從代碼中能夠知道新建立的數組長度爲原數組的2倍(oldCapacity << 1)。建立好新數組後須要將舊數組中的全部元素移到新數組中，所以須要計算每一個元素在新數組中的下標。計算新下標的過程以下圖所示。

Java併發系列（9）ConcurrentHashMap源碼分析

咱們知道下標直接取的是哈希碼的後幾位，因爲新數組的容量是直接用舊數組容量右移1位得來的，所以掩碼位數向右增長1位，取到的哈希碼位數也向右增長1位。如上圖，若舊的掩碼值爲111，則元素下標爲101，擴容後新的掩碼值爲1111，則計算出元素的新下標爲0101。

因爲同一條鏈表上的元素下標是相同的，如今假設鏈表全部元素的下標爲101，在擴容後該鏈表元素的新下標只有0101或1101這兩種狀況，所以數組擴容會打亂原先的鏈表並將鏈表元素分紅兩批。在計算出新下標後須要將元素移動到新數組中，在HashMap中經過直接修改next引用致使了多線程的死鎖。

雖然在ConcurrentHashMap中經過加鎖避免了這種狀況，可是咱們知道next域是volatile類型的，它的改動能立馬被讀線程讀取到，所以爲保證線程安全採用複製元素來遷移數組。可是對鏈表中每一個元素都進行復制有點影響性能，做者發現鏈表尾部有許多元素的next是不變的，它們在新數組中的下標是相同的，所以能夠考慮總體移動這部分元素。具統計實際操做中只有1/6的元素是必須複製的，因此總體移動鏈表尾部元素(lastRun後面的元素)是能夠提高必定性能的。

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程