深入分析ConcurrentHashMap

HashMap的問題

HashMap是不支持併發操作的，多線程情況下HashMap可能會導致死循環的發生，導致CPU佔用率達到100%。

Hash表的數據結構

HashMap通常會用一個指針數組（假設爲table[]）來做分散所有的key，當一個key被加入時，會通過Hash算法通過key算出這個數組的下標i，然後就把這個

HashMap的源碼

public V put(K key, V value) {
    if (table == EMPTY_TABLE) {
        inflateTable(threshold);
    }
    if (key == null)
        return putForNullKey(value);
    //計算Hash值
    int hash = hash(key);
    int i = indexFor(hash, table.length);
    //如果存在值，替換舊值
    for (Entry<K,V> e = table[i]; e != null; e = e.next) {
        Object k;
        if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
            V oldValue = e.value;
            e.value = value;
            e.recordAccess(this);
            return oldValue;
        }
    }

    modCount++;
    //增加節點
    addEntry(hash, key, value, i);
    return null;
}

上面代碼是HashMap進行put一個元素時候的源碼。

void addEntry(int hash, K key, V value, int bucketIndex) {
    //如果大小大於現在的threshold時候，需要resize
    if ((size >= threshold) && (null != table[bucketIndex])) {
        resize(2 * table.length);
        hash = (null != key) ? hash(key) : 0;
        bucketIndex = indexFor(hash, table.length);
    }

    createEntry(hash, key, value, bucketIndex);
}

在增加節點時候會判斷是否需要rehash操作。

 void resize(int newCapacity) {
    Entry[] oldTable = table;
    int oldCapacity = oldTable.length;
    if (oldCapacity == MAXIMUM_CAPACITY) {
        threshold = Integer.MAX_VALUE;
        return;
    }
    //新建一個Hash Table
    Entry[] newTable = new Entry[newCapacity];
    //吧舊oldtable 遷移到新的newTable上
    transfer(newTable, initHashSeedAsNeeded(newCapacity));
    table = newTable;
    threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
}

resize源碼會新建個更大的hash表

void transfer(Entry[] newTable, boolean rehash) {
    int newCapacity = newTable.length;
    //  從OldTable裏摘一個元素出來，然後放到NewTable中
    for (Entry<K,V> e : table) {
        while(null != e) {
            Entry<K,V> next = e.next;
            if (rehash) {
                e.hash = null == e.key ? 0 : hash(e.key);
            }
            int i = indexFor(e.hash, newCapacity);
            e.next = newTable[i];
            newTable[i] = e;
            e = next;
        }
    }
}

遷移源代碼

正常ReHash過程

就像代碼中一樣，新建一個新的table容量比oldtale要大，然後將oldtable中元素遷移到newtable中，在單線程下這樣沒什麼問題。

併發下的Rehash

假設有兩個線程，當第一個線程執行到

    Entry<K, V> next = e.next;

時候被掛起。

假設有三個值， <3,a>,<7,b>,<5,c>,HashMap的初始大小是2
 ______                            
|__0___|          e               next         
 ______        _______          _______          _______ 
|__1___| ---> |_<3,a>_| -----> |_<7,b>_| -----> |_<5,c>_|

那麼現在線程1如下：

 ______    
|__0___|      
|__1___|   
|__2___|      
|__3___|

那麼線程2開始rehash：

 ______    
|__0___|              _______
|__1___| ----------> |_<5,c>_|  ---------> null 
|__2___|       _______          _______ 
|__3___| ---> |_<7,b>_| -----> |_<3,a>_| ----> null
                next               e

那麼如果現在線程1被調度開始執行：

newTable[i] = e;
e = next;

先是執行 newTalbe[i] = e;
然後是e = next，導致了e指向了key(7)，
而下一次循環的next = e.next導致了next指向了key(3)

 ______    
|__0___|              _______
|__1___| ----------> |_<5,c>_|  ---------> null 
|__2___|       _______          _______ 
|__3___| ---> |_<7,b>_| -----> |_<3,a>_| ----> null
                e                 next

這樣就會導致

線程1
 ______    
|__0___|           __________________              
|__1___|          |                 |            
|__2___|       ___|___          ____|__ 
|__3___| ---> |_<3,a>_| -----> |_<7,b>_| ----> null

產生循環鏈表，導致死循環。

concurrentHashMap原理

concurrentHashMap採用鎖分段技術：假如容器裏有多把鎖，每一把鎖用於鎖容器其中一部分數據，那麼當多線程訪問容器裏不同數據段的數據時，線程間就不會存在鎖競爭，從而可以有效的提高併發訪問效率，這就是ConcurrentHashMap所使用的鎖分段技術。首先將數據分成一段一段的存儲，然後給每一段數據配一把鎖，當一個線程佔用鎖訪問其中一個段數據的時候，其他段的數據也能被其他線程訪問。

HashEntry源碼:

static final class HashEntry<K,V> {
        final int hash;
        final K key;
        volatile V value;
        volatile HashEntry<K,V> next;

volatile關鍵字保證了多線程讀取的時候一定是最新值。

ConcurrentHashMap包含一個Segment數組,每個Segment包含一個HashEntry數組,當修改HashEntry數組採用開鏈法處理衝突,所以它的每個HashEntry元素又是鏈表結構的元素。

基本操作源碼分析

構造方法:

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;   //1
    int sshift = 0;
    int ssize = 1;
    while (ssize < concurrencyLevel) {
        ++sshift;
        ssize <<= 1;    //2
    }
    this.segmentShift = 32 - sshift;  //3
    this.segmentMask = ssize - 1;   //4
    if (initialCapacity > MAXIMUM_CAPACITY)
        initialCapacity = MAXIMUM_CAPACITY;
    int c = initialCapacity / ssize;
    if (c * ssize < initialCapacity)
        ++c;
    int cap = MIN_SEGMENT_TABLE_CAPACITY;
    while (cap < c)
        cap <<= 1;
    Segment<K,V> s0 =
        new Segment<K,V>(loadFactor, (int)(cap * loadFactor),
                         (HashEntry<K,V>[])new HashEntry[cap]);//5
    Segment<K,V>[] ss = (Segment<K,V>[])new Segment[ssize]; //6
    UNSAFE.putOrderedObject(ss, SBASE, s0); 
    this.segments = ss;
}

整個初始化是通過參數initialCapacity(初始容量)，loadFactor(增長因子)和concurrencyLevel(併發等級)來初始化segmentShift（段偏移量）、segmentMask（段掩碼）和segment數組。

註釋1: 最大的併發等級不能超過MAX_SEGMENTS 1<<16(也就是1的二進制向左移16位,65535)

註釋2: 如果你傳入的是15 就是向上取2的4次方倍也就是16.

註釋3和4: segmentShift和segmentMask在定位segment使用，segmentShift = 32 - ssize向左移位的次數，segmentMask = ssize - 1。ssize的最大長度是65536，對應的 segmentShift最大值爲16，segmentMask最大值是65535，對應的二進制16位全爲1；

註釋5和6: 初始化segment

初始化每個segment的HashEntry長度；
創建segment數組和segment[0]。

HashEntry長度cap同樣也是2的N次方，默認情況，ssize = 16，initialCapacity = 16，loadFactor = 0.75f，那麼cap = 1，threshold = (int) cap * loadFactor = 0。

get操作

public V get(Object key) {
    Segment<K,V> s; 
    HashEntry<K,V>[] tab;
    int h = hash(key);  //1
    long u = (((h >>> segmentShift) & segmentMask) << SSHIFT) + SBASE;
    if ((s = (Segment<K,V>)UNSAFE.getObjectVolatile(segments, u)) != null &&  //2
        (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)))
                return e.value;
        }
    }
    return null;
}

註釋1: 根據key計算hash值

註釋2: 根據計算出的hash值定位segment 如果segment不爲null segment.table也不爲null 跳轉進裏面的循環

裏面的一大段東西大致講的就是通過hash值定位segment中對應的HashEntry 遍歷HashEntry,如果key存在,返回key對應的value 如果不存在則返回null

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          
         (segments, (j << SSHIFT) + SBASE)) == null) 
        s = ensureSegment(j);
    return s.put(key, hash, value, false);
}

判斷值是否爲null
計算hash值
定位segment 如果不存在，則創建
調用segment的put方法

還有一個putifAbsent的方法 ,唯一的不同就是最後的false變爲了true
再來看看Segment的put方法

final V put(K key, int hash, V value, boolean onlyIfAbsent) {
    HashEntry<K,V> node = tryLock() ? null :
        scanAndLockForPut(key, hash, value);  //1
    V oldValue;
    try {
        HashEntry<K,V>[] tab = table;
        int index = (tab.length - 1) & hash;
        HashEntry<K,V> first = entryAt(tab, index);  //2
        for (HashEntry<K,V> e = first;;) { //3
            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 {
                if (node != null)
                    node.setNext(first);
                else
                    node = new HashEntry<K,V>(hash, key, value, first);
                int c = count + 1;
                if (c > threshold && tab.length < MAXIMUM_CAPACITY)
                    rehash(node);
                else
                    setEntryAt(tab, index, node);
                ++modCount;
                count = c;
                oldValue = null;
                break;
            }
        }
    } finally {
        unlock();
    }
    return oldValue;
}

註釋1: 獲取鎖，保證線程安全

註釋2:定位到具體的HashEntry

註釋3: 遍歷HashEntry鏈表,如果key已存在再判斷傳入的onlyIfAbsent的值 ,再決定是否覆蓋舊值.

最後釋放鎖,返回舊值.

再說明一下put 和 putifAbsent的用法

這兩個方法本身是線程安全的,但是要看你的用法是否恰當

例子:

private static ConcurrentHashMap<String,AtomicInteger> map = new ConcurrentHashMap<>();
public static void putInTo(String key) {
    AtomicInteger obj = map.get(key);
    if(obj == null){
        map.put(key, new AtomicInteger(0));
    }else{
        obj.incrementAndGet();
        map.put(key, obj);
    }
}

這段代碼可以用最開始提供的測試代碼進行測試，會發現如果多個線程調用putInTo方法最後值會確定不了,每一次都是不一樣。就算是保證原子性的AtomicInteger 也會有誤差,可能誤差比較小罷了。這個誤差的出現就會出現在前幾次的操作。

原因: 多個線程同時進入putInTo 比如線程1已經把不存在的鍵值對存入,而線程2還沒完成操作再繼續存入key相同的鍵值對,從而覆蓋了前面存入的數據,導致數據丟失。

這段代碼就能保證線程安全而不用通過synchronized關鍵字來鎖定方法

private static ConcurrentMap<String, AtomicLong> wordCounts = newConcurrentHashMap<>();  

public static long increase(String word) {  
    AtomicLong number = wordCounts.get(word);  
    if(number == null) {  
        AtomicLong newNumber = newAtomicLong(0);  
        number = wordCounts.putIfAbsent(word, newNumber);  
        if(number == null) {  
            number = newNumber;  
        }  
    }  
    return number.incrementAndGet();  
}

獲取size

public int size() {
    final Segment<K,V>[] segments = this.segments;
    int size;
    boolean overflow; 
    long sum;         
    long last = 0L;   
    int retries = -1; 
    try {
        for (;;) {
            if (retries++ == RETRIES_BEFORE_LOCK) {  //1
                for (int j = 0; j < segments.length; ++j)
                    ensureSegment(j).lock(); 
            }
            sum = 0L;
            size = 0;
            overflow = false;
            for (int j = 0; j < segments.length; ++j) {
                Segment<K,V> seg = segmentAt(segments, j);
                if (seg != null) {
                    sum += seg.modCount;  //2
                    int c = seg.count;
                    if (c < 0 || (size += c) < 0)
                        overflow = true;
                }
            }
            if (sum == last)
                break;
            last = sum;
        }
    } finally {
        if (retries > RETRIES_BEFORE_LOCK) {
            for (int j = 0; j < segments.length; ++j)
                segmentAt(segments, j).unlock();
        }
    }
    return overflow ? Integer.MAX_VALUE : size;
}

註釋1 : RETRIES_BEFORE_LOCK爲不變常量2 嘗試兩次不鎖住Segment的方式來統計每個Segment的大小,如果在統計的過程中Segment的count發生變化,這時候再加鎖統計Segment的count

fk5431
http://fk5431.com/20170503/java/concurrentHashMap/

fk5431

發佈了196 篇原創文章 · 獲贊 18 · 訪問量 25萬+

他的留言板關注

深入分析ConcurrentHashMap

HashMap的問題

Hash表的數據結構

HashMap的源碼

正常ReHash過程

併發下的Rehash

concurrentHashMap原理

基本操作源碼分析

get操作

put操作

AI 畫圖真刺激，手把手教你如何用 ComfyUI 來畫出刺激的圖

公司剛入職了一名 Java 中級開發，短短 4 行代碼居然湊齊了 3 個 bug！我哭了~~

數據展示動態（跑分）顯示

公衆號5月C#/.NET熱文一覽

git 下載大陸鏡像地址

不用netty實現OIO和NIO連接通信

線程池閱讀

linux查看內存和cpu使用情況

HashMap閱讀（1.8|1.7）

aqs源碼

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結