亚洲激情专区-91九色丨porny丨老师-久久久久久久女国产乱让韩-国产精品午夜小视频观看

溫馨提示×

溫馨提示×

您好,登錄后才能下訂單哦!

密碼登錄×
登錄注冊×
其他方式登錄
點擊 登錄注冊 即表示同意《億速云用戶服務條款》

如何淺析ConcurrentHashMap

發布時間:2021-12-08 17:30:00 來源:億速云 閱讀:122 作者:柒染 欄目:云計算

如何淺析ConcurrentHashMap,很多新手對此不是很清楚,為了幫助大家解決這個難題,下面小編將為大家詳細講解,有這方面需求的人可以來學習下,希望你能有所收獲。

數據的可見性

直接進入正題,concurrentHashMap相信用的人也很多,因為在數據安全性上確實比HashMap好用,在性能上比hashtable也好用。大家都知道線程在操作一個變量的時候,比如i++,jvm執行的時候需要經過兩個內存,主內存和工作內存。那么在線程A對i進行加1的時候,它需要去主內存拿到變量值,這個時候工作內存中便有了一個變量數據的副本,執行完這些之后,再去對變量真正的加1,但是此時線程B也要操作變量,并且邏輯上也是沒有維護多線程訪問的限制,則很有可能在線程A在從主內存獲取數據并在修改的時候線程B去主內存拿數據,但是這個時候主內存的數據還沒有更新,A線程還沒有來得及講加1后的變量回填到主內存,這個時候變量在這兩個線程操作的情況下就會發生邏輯錯誤。

原子性

原子性就是當某一個線程A修改i的值的時候,從取出i到將新的i的值寫給i之間線程B不能對i進行任何操作。也就是說保證某個線程對i的操作是原子性的,這樣就可以避免數據臟讀。

volatile的作用

Volatile保證了數據在多線程之間的可見性,每個線程在獲取volatile修飾的變量時候都回去主內存獲取,所以當線程A修改了被volatile修飾的數據后其他線程看到的一定是修改過后最新的數據,也是因為volatile修飾的變量數據每次都要去主內存獲取,在性能上會有些犧牲。

措施

HashMap在多線程的場景下是不安全的,hashtable雖然是在數據表上加鎖,縱然數據安全了,但是性能方面確實不如HashMap。那么來看看concurrentHashMap是如何解決這些問題的。

concurrentHashMap由多個segment組成,每一個segment都包含了一個HashEntry數組的hashtable, 每一個segment包含了對自己的hashtable的操作,比如get,put,replace等操作(這些操作與HashMap邏輯都是一樣的,不同的是concurrentHashMap在執行這些操作的時候加入了重入鎖ReentrantLock),這些操作發生的時候,對自己的hashtable進行鎖定。由于每一個segment寫操作只鎖定自己的hashtable,所以可能存在多個線程同時寫的情況,性能無疑好于只有一個hashtable鎖定的情況。通俗的講就是concurrentHashMap由多個hashtable組成。

源碼

看下concurrentHashMap的remove操作

V remove(Object key, int hash, Object value) {
            lock();//重入鎖
            try {
                int c = count - 1;
                HashEntry<K,V>[] tab = table;
                int index = hash & (tab.length - 1);
                HashEntry<K,V> first = tab[index];
                HashEntry<K,V> e = first;
                while (e != null && (e.hash != hash || !key.equals(e.key)))
                    e = e.next;

                V oldValue = null;
                if (e != null) {
                    V v = e.value;
                    if (value == null || value.equals(v)) {
                        oldValue = v;
                        // All entries following removed node can stay
                        // in list, but all preceding ones need to be
                        // cloned.
                        ++modCount;
                        HashEntry<K,V> newFirst = e.next;
                        for (HashEntry<K,V> p = first; p != e; p = p.next)
                            newFirst = new HashEntry<K,V>(p.key, p.hash,
                                                          newFirst, p.value);
                        tab[index] = newFirst;
                        count = c; // write-volatile
                    }
                }
                return oldValue;
            } finally {
                unlock();//釋放鎖
            }
        }

Count是被volatile所修飾,保證了count的可見性,避免操作數據的時候產生邏輯錯誤。segment中的remove操作和HashMap大致一樣,HashMap沒有lock()和unlock()操作。

看下concurrentHashMap的get源碼

V get(Object key, int hash) {
            if (count != 0) { // read-volatile
                HashEntry<K,V> e = getFirst(hash);
        //如果沒有找到則直接返回null
                while (e != null) {
                    if (e.hash == hash && key.equals(e.key)) {
            //由于沒有加鎖,在get的過程中,可能會有更新,拿到的key對應的value可能為null,需要單獨判斷一遍
                        V v = e.value;
            //如果value為不為null,則返回獲取到的value
                        if (v != null)
                            return v;
                        return readValueUnderLock(e); // recheck
                    }
                    e = e.next;
                }
            }
            return null;
        }

關于concurrentHashMap的get的相關說明已經在上面代碼中給出了注釋,這里就不多說了。

看下concurrentHashMap中的put

public V put(K key, V value) {
        if (value == null)
            throw new NullPointerException();
        int hash = hash(key.hashCode());
        return segmentFor(hash).put(key, hash, value, false);
}

可以看到concurrentHashMap不允許key或者value為null

接下來看下segment的put

V put(K key, int hash, V value, boolean onlyIfAbsent) {
            lock();
            try {
                int c = count;
                if (c++ > threshold) // ensure capacity
                    rehash();
                HashEntry<K,V>[] tab = table;
                int index = hash & (tab.length - 1);
                HashEntry<K,V> first = tab[index];
                HashEntry<K,V> e = first;
                while (e != null && (e.hash != hash || !key.equals(e.key)))
                    e = e.next;

                V oldValue;
                if (e != null) {
                    oldValue = e.value;
                    if (!onlyIfAbsent)
                        e.value = value;
                }
                else {
                    oldValue = null;
                    ++modCount;
                    tab[index] = new HashEntry<K,V>(key, hash, first, value);
                    count = c; // write-volatile
                }
                return oldValue;
            } finally {
                unlock();
            }
        }

 同樣也是加入了重入鎖,其他的基本和HashMap邏輯差不多。值得一提的是jdk8中添加的中的putval,這里就不多說了。

ConcurrentHashmap將數據結構分為了多個Segment,也是使用重入鎖來解決高并發,講他分為多個segment是為了減小鎖的力度,添加的時候加了鎖,索引的時候沒有加鎖,使用volatile修飾count是為了保持count的可見性,都是jdk為了解決并發和多線程操作的常用手段。

看完上述內容是否對您有幫助呢?如果還想對相關知識有進一步的了解或閱讀更多相關文章,請關注億速云行業資訊頻道,感謝您對億速云的支持。

向AI問一下細節

免責聲明:本站發布的內容(圖片、視頻和文字)以原創、轉載和分享為主,文章觀點不代表本網站立場,如果涉及侵權請聯系站長郵箱:is@yisu.com進行舉報,并提供相關證據,一經查實,將立刻刪除涉嫌侵權內容。

AI

富顺县| 驻马店市| 兴业县| 甘谷县| 屏东市| 西贡区| 奉化市| 集贤县| 孟村| 聂拉木县| 来安县| 板桥市| 永昌县| 廉江市| 抚顺县| 东兰县| 布尔津县| 伊金霍洛旗| 朝阳区| 绩溪县| 夹江县| 浦江县| 罗源县| 赤壁市| 平远县| 湘潭市| 余姚市| 安徽省| 嘉荫县| 鸡泽县| 大宁县| 黑山县| 额敏县| 赤水市| 武平县| 唐山市| 姚安县| 辽阳市| 营山县| 准格尔旗| 乐业县|