集合是程式設計中最常用的資料結構。而談到併發，幾乎總是離不開集合這類高階資料結構的支援。比如兩個執行緒需要同時訪問一箇中間臨界區（Queue），比如常會用快取作為外部檔案的副本（HashMap）。這篇文章主要分析jdk1.5的3種併發集合型別（concurrent，copyonright，queue）中的ConcurrentHashMap，讓我們從原理上細緻的瞭解它們，能夠讓我們在深度專案開發中獲益非淺。

    通過分析Hashtable就知道，synchronized是針對整張Hash表的，即每次鎖住整張表讓執行緒獨佔，ConcurrentHashMap允許多個修改操作併發進行，其關鍵在於使用了鎖分離技術。它使用了多個鎖來控制對hash表的不同部分進行的修改。ConcurrentHashMap內部使用段(Segment)來表示這些不同的部分，每個段其實就是一個小的hash table，它們有自己的鎖。只要多個修改操作發生在不同的段上，它們就可以併發進行。

有些方法需要跨段，比如size()和containsValue()，它們可能需要鎖定整個表而而不僅僅是某個段，這需要按順序鎖定所有段，操作完畢後，又按順序釋放所有段的鎖。這裡“按順序”是很重要的，否則極有可能出現死鎖，在ConcurrentHashMap內部，段陣列是final的，並且其成員變數實際上也是final的，但是，僅僅是將陣列宣告為final的並不保證陣列成員也是final的，這需要實現上的保證。這可以確保不會出現死鎖，因為獲得鎖的順序是固定的。

 一、結構解析

   ConcurrentHashMap和Hashtable主要區別就是圍繞著鎖的粒度以及如何鎖,可以簡單理解成把一個大的HashTable分解成多個，形成了鎖分離。如圖:

而Hashtable的實現方式是---鎖整個hash表

二、應用場景

當有一個大陣列時需要在多個執行緒共享時就可以考慮是否把它給分層多個節點了，避免大鎖。並可以考慮通過hash演算法進行一些模組定位。

其實不止用於執行緒，當設計資料表的事務時（事務某種意義上也是同步機制的體現），可以把一個表看成一個需要同步的陣列，如果操作的表資料太多時就可以考慮事務分離了（這也是為什麼要避免大表的出現），比如把資料進行欄位拆分，水平分表等.

三、原始碼解讀

 ConcurrentHashMap中主要實體類就是三個：ConcurrentHashMap（整個Hash表）,Segment（桶），HashEntry（節點），對應上面的圖可以看出之間的關係

/** 
* The segments, each of which is a specialized hash table 
*/  
final Segment<K,V>[] segments; 

不變(Immutable)和易變(Volatile)
ConcurrentHashMap完全允許多個讀操作併發進行，讀操作並不需要加鎖。如果使用傳統的技術，如HashMap中的實現，如果允許可以在hash鏈的中間新增或刪除元素，讀操作不加鎖將得到不一致的資料。ConcurrentHashMap實現技術是保證HashEntry幾乎是不可變的。HashEntry代表每個hash鏈中的一個節點，其結構如下所示：

1. static final class HashEntry<K,V> {  
2.     final K key;  
3.     final int hash;  
4.     volatile V value;  
5.     final HashEntry<K,V> next;  
6. }  

可以看到除了value不是final的，其它值都是final的，這意味著不能從hash鏈的中間或尾部新增或刪除節點，因為這需要修改next 引用值，所有的節點的修改只能從頭部開始。對於put操作，可以一律新增到Hash鏈的頭部。但是對於remove操作，可能需要從中間刪除一個節點，這就需要將要刪除節點的前面所有節點整個複製一遍，最後一個節點指向要刪除結點的下一個結點。這在講解刪除操作時還會詳述。為了確保讀操作能夠看到最新的值，將value設定成volatile，這避免了加鎖。
其它
為了加快定位段以及段中hash槽的速度，每個段hash槽的的個數都是2^n，這使得通過位運算就可以定位段和段中hash槽的位置。當併發級別為預設值16時，也就是段的個數，hash值的高4位決定分配在哪個段中。但是我們也不要忘記《演算法導論》給我們的教訓：hash槽的的個數不應該是 2^n，這可能導致hash槽分配不均，這需要對hash值重新再hash一次。（這段似乎有點多餘了 ）

這是定位段的方法：

1. final Segment<K,V> segmentFor(int hash) {  
2.     return segments[(hash >>> segmentShift) & segmentMask];  
3. } 

資料結構
關於Hash表的基礎資料結構，這裡不想做過多的探討。Hash表的一個很重要方面就是如何解決hash衝突，ConcurrentHashMap 和HashMap使用相同的方式，都是將hash值相同的節點放在一個hash鏈中。與HashMap不同的是，ConcurrentHashMap使用多個子Hash表，也就是段(Segment)。下面是ConcurrentHashMap的資料成員：

1. public class ConcurrentHashMap<K, V> extends AbstractMap<K, V>  
2.         implements ConcurrentMap<K, V>, Serializable {  
3.     /** 
4.      * Mask value for indexing into segments. The upper bits of a 
5.      * key's hash code are used to choose the segment. 
6.      */  
7.     final int segmentMask;  
8.   
9.     /** 
10.      * Shift value for indexing within segments. 
11.      */  
12.     final int segmentShift;  
13.   
14.     /** 
15.      * The segments, each of which is a specialized hash table 
16.      */  
17.     final Segment<K,V>[] segments;  
18. } 

所有的成員都是final的，其中segmentMask和segmentShift主要是為了定位段，參見上面的segmentFor方法。
每個Segment相當於一個子Hash表，它的資料成員如下：

1.     static final class Segment<K,V> extends ReentrantLock implements Serializable {  
2. private static final long serialVersionUID = 2249069246763182397L;  
3.         /** 
4.          * The number of elements in this segment's region. 
5.          */  
6.         transient volatile int count;  
7.   
8.         /** 
9.          * Number of updates that alter the size of the table. This is 
10.          * used during bulk-read methods to make sure they see a 
11.          * consistent snapshot: If modCounts change during a traversal 
12.          * of segments computing size or checking containsValue, then 
13.          * we might have an inconsistent view of state so (usually) 
14.          * must retry. 
15.          */  
16.         transient int modCount;  
17.   
18.         /** 
19.          * The table is rehashed when its size exceeds this threshold. 
20.          * (The value of this field is always <tt>(int)(capacity * 
21.          * loadFactor)</tt>.) 
22.          */  
23.         transient int threshold;  
24.   
25.         /** 
26.          * The per-segment table. 
27.          */  
28.         transient volatile HashEntry<K,V>[] table;  
29.   
30.         /** 
31.          * The load factor for the hash table.  Even though this value 
32.          * is same for all segments, it is replicated to avoid needing 
33.          * links to outer object. 
34.          * @serial 
35.          */  
36.         final float loadFactor;  
37. } 

count用來統計該段資料的個數，它是volatile(volatile 變數使用指南)，它用來協調修改和讀取操作，以保證讀取操作能夠讀取到幾乎最新的修改。協調方式是這樣的，每次修改操作做了結構上的改變，如增加/刪除節點(修改節點的值不算結構上的改變)，都要寫count值，每次讀取操作開始都要讀取count的值。這利用了 Java 5中對volatile語義的增強，對同一個volatile變數的寫和讀存在happens-before關係。modCount統計段結構改變的次數，主要是為了檢測對多個段進行遍歷過程中某個段是否發生改變，在講述跨段操作時會還會詳述。threashold用來表示需要進行rehash的界限值。table陣列儲存段中節點，每個陣列元素是個hash鏈，用HashEntry表示。table也是volatile，這使得能夠讀取到最新的 table值而不需要同步。loadFactor表示負載因子。

先來看下刪除操作remove(key)。

1. public V remove(Object key) {  
2.  hash = hash(key.hashCode());  
3.     return segmentFor(hash).remove(key, hash, null);  
4. }  
整個操作是先定位到段，然後委託給段的remove操作。當多個刪除操作併發進行時，只要它們所在的段不相同，它們就可以同時進行。下面是Segment的remove方法實現：
1. V remove(Object key, int hash, Object value) {  
2.     lock();  
3.     try {  
4.         int c = count - 1;  
5.         HashEntry<K,V>[] tab = table;  
6.         int index = hash & (tab.length - 1);  
7.         HashEntry<K,V> first = tab[index];  
8.         HashEntry<K,V> e = first;  
9.         while (e != null && (e.hash != hash || !key.equals(e.key)))  
10.             e = e.next;  
11.   
12.         V oldValue = null;  
13.         if (e != null) {  
14.             V v = e.value;  
15.             if (value == null || value.equals(v)) {  
16.                 oldValue = v;  
17.                 // All entries following removed node can stay  
18.                 // in list, but all preceding ones need to be  
19.                 // cloned.  
20.                 ++modCount;  
21.                 HashEntry<K,V> newFirst = e.next;  
22.                 *for (HashEntry<K,V> p = first; p != e; p = p.next)  
23.                     *newFirst = new HashEntry<K,V>(p.key, p.hash,  
24.                                                   newFirst, p.value);  
25.                 tab[index] = newFirst;  
26.                 count = c; // write-volatile  
27.             }  
28.         }  
29.         return oldValue;  
30.     } finally {  
31.         unlock();  
32.     }  
33. } 

整個操作是在持有段鎖的情況下執行的，空白行之前的行主要是定位到要刪除的節點e。接下來，如果不存在這個節點就直接返回null，否則就要將e前面的結點複製一遍，尾結點指向e的下一個結點。e後面的結點不需要複製，它們可以重用。

中間那個for迴圈是做什麼用的呢？（*號標記）從程式碼來看，就是將定位之後的所有entry克隆並拼回前面去，但有必要嗎？每次刪除一個元素就要將那之前的元素克隆一遍？這點其實是由entry的不變性來決定的，仔細觀察entry定義，發現除了value，其他所有屬性都是用final來修飾的，這意味著在第一次設定了next域之後便不能再改變它，取而代之的是將它之前的節點全都克隆一次。至於entry為什麼要設定為不變性，這跟不變性的訪問不需要同步從而節省時間有關

下面是個示意圖

刪除元素之前：

刪除元素3之後：

第二個圖其實有點問題，複製的結點中應該是值為2的結點在前面，值為1的結點在後面，也就是剛好和原來結點順序相反，還好這不影響我們的討論。

整個remove實現並不複雜，但是需要注意如下幾點。第一，當要刪除的結點存在時，刪除的最後一步操作要將count的值減一。這必須是最後一步操作，否則讀取操作可能看不到之前對段所做的結構性修改。第二，remove執行的開始就將table賦給一個區域性變數tab，這是因為table是 volatile變數，讀寫volatile變數的開銷很大。編譯器也不能對volatile變數的讀寫做任何優化，直接多次訪問非volatile例項變數沒有多大影響，編譯器會做相應優化。

接下來看put操作，同樣地put操作也是委託給段的put方法。下面是段的put方法：

1. V put(K key, int hash, V value, boolean onlyIfAbsent) {  
2.     lock();  
3.     try {  
4.         int c = count;  
5.         if (c++ > threshold) // ensure capacity  
6.             rehash();  
7.         HashEntry<K,V>[] tab = table;  
8.         int index = hash & (tab.length - 1);  
9.         HashEntry<K,V> first = tab[index];  
10.         HashEntry<K,V> e = first;  
11.         while (e != null && (e.hash != hash || !key.equals(e.key)))  
12.             e = e.next;  
13.   
14.         V oldValue;  
15.         if (e != null) {  
16.             oldValue = e.value;  
17.             if (!onlyIfAbsent)  
18.                 e.value = value;  
19.         }  
20.         else {  
21.             oldValue = null;  
22.             ++modCount;  
23.             tab[index] = new HashEntry<K,V>(key, hash, first, value);  
24.             count = c; // write-volatile  
25.         }  
26.         return oldValue;  
27.     } finally {  
28.         unlock();  
29.     }  
30. } 

該方法也是在持有段鎖(鎖定整個segment)的情況下執行的，這當然是為了併發的安全，修改資料是不能併發進行的，必須得有個判斷是否超限的語句以確保容量不足時能夠rehash。接著是找是否存在同樣一個key的結點，如果存在就直接替換這個結點的值。否則建立一個新的結點並新增到hash鏈的頭部，這時一定要修改modCount和count的值，同樣修改count的值一定要放在最後一步。put方法呼叫了rehash方法，reash方法實現得也很精巧，主要利用了table的大小為2^n，這裡就不介紹了。而比較難懂的是這句int index = hash & (tab.length - 1)，原來segment裡面才是真正的hashtable，即每個segment是一個傳統意義上的hashtable,如上圖，從兩者的結構就可以看出區別，這裡就是找出需要的entry在table的哪一個位置，之後得到的entry就是這個鏈的第一個節點，如果e!=null，說明找到了，這是就要替換節點的值（onlyIfAbsent == false），否則，我們需要new一個entry，它的後繼是first，而讓tab[index]指向它，什麼意思呢？實際上就是將這個新entry插入到鏈頭，剩下的就非常容易理解了

修改操作還有putAll和replace。putAll就是多次呼叫put方法，沒什麼好說的。replace甚至不用做結構上的更改，實現要比put和delete要簡單得多，理解了put和delete，理解replace就不在話下了，這裡也不介紹了。
獲取操作
首先看下get操作，同樣ConcurrentHashMap的get操作是直接委託給Segment的get方法，直接看Segment的get方法：

1. V get(Object key, int hash) {  
2.     if (count != 0) { // read-volatile 當前桶的資料個數是否為0 
3.         HashEntry<K,V> e = getFirst(hash);  得到頭節點
4.         while (e != null) {  
5.             if (e.hash == hash && key.equals(e.key)) {  
6.                 V v = e.value;  
7.                 if (v != null)  
8.                     return v;  
9.                 return readValueUnderLock(e); 
            
  
           

              
              
            
            
相關推薦
			   
            
            
            
 

    

    
    
Java集合---ConcurrentHashMap原理分析（面試問題：ConcurrentHashMap實現原理是怎麼樣的）
     
 
                

集合是程式設計中最常用的資料結構。而談到併發，幾乎總是離不開集合這類高階資料結構的支援。比如兩個執行緒需要同時訪問一箇中間臨界區（Queue），比如常會用快取作為外部檔案的副本（HashMap）。這篇文章主要分析jdk1.5的3種併發集合型別（concurrent，cop 

  
 

    

    
    
轉：HashMap實現原理分析（面試問題：兩個hashcode相同 的對象怎麽存入hashmap的）
     
 影響   strong   就會   怎麽   ash   地方   shm   nbsp   擔心   原文地址：https://www.cnblogs.com/faunjoe88/p/7992319.html
主要內容：
1）put
 
疑問：如果兩個key通過hash%Entry[].length得到的 

  
 

    

    
    
HashMap實現原理分析（面試問題：兩個hashcode相同 的物件怎麼存入hashmap的）
     
 
                
1. HashMap的資料結構
資料結構中有陣列和連結串列來實現對資料的儲存，但這兩者基本上是兩個極端。
      陣列
陣列儲存區間是連續的，佔用記憶體嚴重，故空間複雜的很大。但陣列的二分查詢時間複雜度小，為O(1)；陣列的特點是：定址容易，插入和刪除困難；
連結串列
 

  
 

    

    
    
Java集合源碼分析（四）HashMap
     
 cto   情況下   base   分布   我們   ron   建立   city   不同   一、HashMap簡介
1.1、HashMap概述
　　HashMap是基於哈希表的Map接口實現的，它存儲的是內容是鍵值對<key,value>映射。此類不保證映射的順序，假定哈希函數將元 

  
 

    

    
    
java集合包總結(新增、刪除等操作實現原理)
     
 
                

1.集合包
常用的是Collection與Map兩個介面的實現類。
Collection常用的兩種介面：List和Set。
List實現類：ArrayList、LinkedList、Vector、Stack。
Set實現類：HashSet、TreeSet。
Collect 

  
 

    

    
    
IOS -- XMPPFramework 即時聊天（3：XMPPFramework 實現連線伺服器）
     
 
                
1.首先我來認識這些物件名詞的含義。



XMPPStream：xmpp基礎服務類


XMPPRoster：好友列表類


XMPPRosterCoreDataStorage：好友列表（使用者賬號）在core data中的操作類


XMPPvCardCoreDataS 

  
 

    

    
    
Go Ticker實現原理剖析（輕鬆掌握Ticker實現原理）
     
 
                                        
                                                前言
本節我們從Ticker資料結構入手，結合原始碼分析Ticker的實現原理。
實際上，Ticker與之前講的Timer幾乎完全 

  
 

    

    
    
Java集合---ConcurrentHashMap原理分析（轉）
     
 
                

    轉載自： http://www.cnblogs.com/ITtangtang/p/3948786.html  

    感謝作者




集合是程式設計中最常用的資料結構。而談到併發，幾乎總是離不開集合這類高階資料結構的支援。比如兩個執行緒需要同時訪問一箇中間臨 

  
 

    

    
    
XSS的原理分析與解剖：第三章（技巧篇）**************未看*****************
     
 第二章   !=   chrom   插入   是把   調用   bject   innerhtml   ats   ??0×01 前言: 
 
關於前兩節url：
第一章：http://www.freebuf.com/articles/web/40520.html 
第二章：http://www.free 

  
 

    

    
    
Java並發AQS原理分析（一）
     
 jpg   子類   ole   success   ces   ||   pro   同步   無法   我們說的AQS就是AbstractQueuedSynchronizer，他在java.util.concurrent.locks包下，這個類是Java並發的一個核心類。第一次知道有這個類是在看可重入鎖R 

  
 

    

    
    
java線程基礎鞏固---wait和sleep的本質區別是什麽，深入分析（面試常見問題）
     
 是什麽   執行   就是   需要   喚醒   直接   png   java線程   解釋   對於wait和sleep貌似都會阻塞線程，但是它們確實是很大的區別的，所以下面一點點來探討：

區別一、Sleep()是線程裏面的方法，而Wait()是Object類的方法。這個比較簡單，直接看代碼便知： 

  
 

    

    
    
Java集合框架閱讀筆記（三）ConcurrentHashMap
     
 類繼承   only   d+   nan   next   related   ati   null   lur   預備知識

AQS(AbstractQueuedSynchronizer)：提供了一個框架用來構造同步一些工具類比如ReentrantLock、 CopyOnWriteArrayList、  

  
 

    

    
    
Java併發（三）：synchronized實現原理
     
 一、synchronized用法 
Java中的同步塊用synchronized標記。 
同步塊在Java中是同步在某個物件上（監視器物件）。 
所有同步在一個物件上的同步塊在同時只能被一個執行緒進入並執行操作。 
所有其他等待進入該同步塊的執行緒將被阻塞，直到執行該同步塊中的執行緒退出。 
（注：不要使用全 

  
 

    

    
    
（二）Java集合專題-詳細分析HashtableJDK1.8集合底層實現的思想
     
  
 
  
  
 （一）詳細分析Hashtable1.8集合底層實現的思路和原始碼 
 （1）先來看一下Hashtable的結構圖：首先他和HashMap結構都是一樣的，都是由陣列和連結串列進行實現的（在JDK1.8是用陣列和連結串列和紅黑樹的），每一個數組裡面存的是一個Entry節點，節點裡面有Key、 

  
 

    

    
    
java併發程式設計一一執行緒池原理分析（三）
     
  
 
  
  
 合理的設定執行緒池的大小 
 接著上一篇探討執行緒留下的尾巴。如果合理的設定執行緒池的大小。 要想合理的配置執行緒池的大小、首先得分析任務的特性，可以從以下幾個角度分析： 1、任務的性質：CPU密集型任務、IO密集型任務、混合型任務等； 2、任務的優先順序：高、中、低； 3、任務的執行時 

  
 

    

    
    
Java併發（十九）：final實現原理 淺談Java中的final關鍵字
     
 final在Java中是一個保留的關鍵字，可以宣告成員變數、方法、類以及本地變數。 
一旦你將引用宣告作final，你將不能改變這個引用了，編譯器會檢查程式碼，如果你試圖將變數再次初始化的話，編譯器會報編譯錯誤。 
一、final變數 
　　final成員變量表示常量，只能被賦值一次，賦值後值不再改變（fin 

  
 

    

    
    
Spring Cloud Eureka原理分析（一）：註冊過程-服務端
     
 Eureka的官方文件和Spring Cloud Eureka文件都有很多含糊的地方，其他資料也不多，只有讀讀原始碼維持生活這樣子…… 
本文將不會詳細介紹每個細節，而是講述一些關鍵的地方，便於查閱。 
一些好的參考資料 
 
 對讓人一臉懵逼的region和zone的解釋 
 攜程對Eureka機制的剖析  

  
 

    

    
    
Spring Cloud Eureka原理分析（二）：續租、下線、自我保護機制和自動清理（服務端）
     
 續租、下線等操作比較直觀，實際上也不復雜。讓我們自己想想它們大概會在服務端有什麼操作。 
 
 renew: 更新Lease的lastUpdateTimestamp, 更新一下InstanceInfo的最新狀態。然後呼叫其他同伴節點的renew介面。 
 cancel：把lease從registry中移除，設 

  
 

    

    
    
java集合之----HashMap原始碼分析（基於JDK1.7與1.8）
     
  
  
  
 一、什麼是HashMap 
 百度百科這樣解釋：  簡而言之，HashMap儲存的是鍵值對（key和value），通過key對映到value，具有很快的訪問速度。HashMap是非執行緒安全的，也就是說在多執行緒併發環境下會出現問題（死迴圈） 
 二、內部實現 
 （1）結構 
 HashM 

  
 

    

    
    
ConcurrentHashMap & HashMap最清晰的底層原理分析（基於JDK1.7跟1.8比較）
     
 
                前言

Map 這樣的 Key  Value 在軟體開發中是非常經典的結構，常用於在記憶體中存放資料。

本篇主要想討論 ConcurrentHashMap 這樣一個併發容器，在正式開始之前我覺得有必要談談 HashMap，沒有它就不會有後面的 ConcurrentHashM