源碼分析——HashMap

時間 2019-11-08

標籤源碼分析 hashmap 简体版

原文原文鏈接

前言

HashMap：它根據鍵的hashCode值存儲數據，大多數狀況下能夠直接定位到它的值，於是訪問的時間複雜度爲常數級，但遍歷的順序倒是無序的。 HashMap最多隻容許一個key爲null，容許多個key的value值爲null。HashMap非線程安全，即任一時刻能夠有多個線程同時寫HashMap，可能會致使數據的不一致。若是須要知足線程安全，可使用ConcurrentHashMap。如下是它的類關係圖：

1. 存儲結構

從數據結構實現來說，HashMap是數組+鏈表+紅黑樹（JDK1.8增長了紅黑樹部分）實現的

這裏須要講明白兩個問題：數據底層具體存儲的是什麼？這樣的存儲方式有什麼優勢呢？

(1) 從源碼可知，HashMap類中有一個很是重要的字段，就是 Node[] table，即哈希桶數組，明顯它是一個Node的數組。咱們先來看看Node是什麼。html

static class Node implements Map.Entry<K,V> {
        final int hash;
        final K key;
        V value;
        Node next;//指向鏈表的下一個node

        Node(int hash, K key, V value, Node next) { ... }
        public final K getKey(){ ... }
        public final V getValue() { ... }
        public final String toString() { ... }
        public final int hashCode() { ... }
        public final V setValue(V newValue) { ... }
        public final boolean equals(Object o) { ... }
}複製代碼

Node是HashMap的一個內部類，實現了Map.Entry接口，本質是就是一個映射(鍵值對)。上圖中的每一個黑色圓點就是一個Node對象。

(2) HashMap就是使用哈希表來存儲的。哈希表爲解決衝突，能夠採用開放地址法和鏈地址法等來解決問題，Java中HashMap採用了鏈地址法。java

鏈地址法，簡單來講，就是數組加鏈表的結合。在每一個數組元素上都有一個鏈表結構，當數據被Hash後，獲得數組下標，把數據放在對應下標元素的鏈表上（具體內容下文會說到）。node

在理解Hash和擴容流程以前，咱們得先了解下HashMap的幾個字段。從HashMap的默認構造函數源碼可知，構造函數就是對下面幾個字段進行初始化，源碼以下：程序員

int threshold;             // 所能容納的key-value對極限 
final float loadFactor;    // 負載因子
int modCount;  
int size;複製代碼

首先，Node[] table的初始化長度length(默認值是16)，Load factor爲負載因子(默認值是0.75)，threshold是HashMap所能容納的最大數據量的Node(鍵值對)個數。threshold = length * Load factor。也就是說，在數組定義好長度以後，負載因子越大，所能容納的鍵值對個數越多。

結合負載因子的定義公式可知，threshold就是在此Load factor和length(數組長度)對應下容許的最大元素數目，超過這個數目就從新resize(擴容)，擴容後的HashMap容量是以前容量的兩倍。默認的負載因子0.75是對空間和時間效率的一個平衡選擇。

size這個字段其實很好理解，就是HashMap中實際存在的鍵值對數量。注意和table的長度length、容納最大鍵值對數量threshold的區別。算法

modCount字段主要用來記錄HashMap內部結構發生變化的次數，主要用於迭代的快速失敗。強調一點，內部結構發生變化指的是結構發生變化，例如put新鍵值對，可是某個key對應的value值被覆蓋不屬於結構變化。數組

這裏存在一個問題，即便負載因子和Hash算法設計的再合理，也免不了會出現拉鍊過長的狀況，一旦出現拉鍊過長，則會嚴重影響HashMap的性能。因而，在JDK1.8版本中，對數據結構作了進一步的優化，引入了紅黑樹。而當鏈表長度太長（默認超過8）時，鏈表就轉換爲紅黑樹，利用紅黑樹快速增刪改查的特色提升HashMap的性能，其中會用到紅黑樹的插入、刪除、查找等算法。

1.1. 拉鍊法的工做原理

HashMap<String, String> map = new HashMap<>(); map.put("K1", "V1"); map.put("K2", "V2"); map.put("K3", "V3");

新建一個 HashMap，默認大小爲 16；
插入 <K1,V1> 鍵值對，先計算 K1 的 hashCode 爲 115，使用除留餘數法獲得所在的桶下標 115%16=3。
插入 <K2,V2> 鍵值對，先計算 K2 的 hashCode 爲 118，使用除留餘數法獲得所在的桶下標 118%16=6。
插入 <K3,V3> 鍵值對，先計算 K3 的 hashCode 爲 118，使用除留餘數法獲得所在的桶下標 118%16=6，插在 <K2,V2> 前面。

應該注意到鏈表的插入是以頭插法方式進行的，例如上面的 <K3,V3> 不是插在 <K2,V2> 後面，而是插入在鏈表頭部。

查找須要分紅兩步進行：

計算鍵值對所在的桶；
在鏈表上順序查找，時間複雜度顯然和鏈表的長度成正比。

1.2. 構造函數解析

計算數組容量

HashMap 構造函數容許用戶傳入的容量不是 2 的 n 次方，由於它能夠自動地將傳入的容量轉換爲 2 的 n 次方。

如下是 HashMap 中計算數組容量的代碼：

static final int tableSizeFor(int cap) {
    int n = cap - 1;
    n |= n >>> 1;
    n |= n >>> 2;
    n |= n >>> 4;
    n |= n >>> 8;
    n |= n >>> 16;
    return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}複製代碼

2. 實現原理

HashMap的內部功能實現不少，本文主要從 根據key獲取哈希桶數組索引位置、put方法的詳細執行、擴容過程三個具備表明性的點深刻展開講解。

2.1. 肯定哈希桶數組索引位置

無論增長、刪除、查找鍵值對，定位到哈希桶數組的位置都是很關鍵的第一步。前面說過HashMap的數據結構是數組和鏈表的結合，因此咱們固然但願這個HashMap裏面的元素位置儘可能分佈均勻些，儘可能使得每一個位置上的元素數量只有一個，那麼當咱們用hash算法求得這個位置的時候，立刻就能夠知道對應位置的元素就是咱們要的，不用遍歷鏈表，大大優化了查詢的效率。HashMap定位數組索引位置，直接決定了hash方法的離散性能。先看看源碼的實現(方法一+方法二):

方法一：
static final int hash(Object key) {   //jdk1.8 & jdk1.7
     int h;
     // h = key.hashCode() 爲第一步 取hashCode值
     // h ^ (h >>> 16) 爲第二步 高位參與運算
     return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
方法二：
static int indexFor(int h, int length) {
//jdk1.7的源碼，jdk1.8沒有這個方法，原理是同樣的只不過放到其餘方法中去，例如put()
     return h & (length-1);  //第三步 取模運算
}複製代碼

這裏的Hash算法分爲三步：取key的hashCode值、高位運算、取模運算。

對於任意給定的對象，只要它的hashCode()返回值相同，那麼程序調用方法一所計算獲得的Hash碼值老是相同的。咱們首先想到的就是把hash值對數組長度取模運算，這樣一來，元素的分佈相對來講是比較均勻的。可是，模運算的消耗仍是比較大的，在HashMap中是這樣作的：調用方法二來計算該對象應該保存在table數組的哪一個索引處。安全

這個方法很是巧妙，它經過h & (table.length -1)來獲得該對象的保存位，而HashMap底層數組的長度老是2的n次方，這是HashMap在速度上的優化。當length老是2的n次方時，h& (length-1)運算等價於對length取模，也就是h%length，可是&比%具備更高的效率。bash

取模的原理解析

令 x = 1<<4，即 x 爲 2 的 4 次方，它具備如下性質：

x   : 00010000
x-1 : 00001111
複製代碼

令一個數 y 與 x-1 作與運算，能夠去除 y 位級表示的第 4 位以上數：

y       : 10110010
x-1     : 00001111
y&(x-1) : 00000010複製代碼

這個性質和 y 對 x 取模效果是同樣的：

y   : 10110010
x   : 00010000
y%x : 00000010複製代碼

位運算的代價比求模運算小的多，所以在進行這種計算時用位運算的話能帶來更高的性能。

肯定桶下標的最後一步是將 key 的 hash 值對桶個數取模：hash%capacity，若是能保證 capacity 爲 2 的 n 次方，那麼就能夠將這個操做轉換爲位運算。

2.2. 分析HashMap的put方法

HashMap的put方法執行過程能夠經過下圖來理解，經過該圖對比源碼能夠更清楚地研究學習。

put執行過程

①.判斷鍵值對數組table[i]是否爲空或爲null，不然執行resize()進行擴容；

②.根據鍵值key計算hash值獲得插入的數組索引i，若是table[i]==null，直接新建節點添加，轉向⑥，若是table[i]不爲空，轉向③；

③.判斷table[i]的首個元素是否和key同樣，若是相同直接覆蓋value，不然轉向④，這裏的相同指的是hashCode以及equals；

④.判斷table[i] 是否爲treeNode，即table[i] 是不是紅黑樹，若是是紅黑樹，則直接在樹中插入鍵值對，不然轉向⑤；

⑤.遍歷table[i]，判斷鏈表長度是否大於8，大於8的話把鏈表轉換爲紅黑樹，在紅黑樹中執行插入操做，不然進行鏈表的插入操做；遍歷過程當中若發現key已經存在直接覆蓋value便可；

⑥.插入成功後，判斷實際存在的鍵值對數量size是否超多了最大容量threshold，若是超過，進行擴容。

JDK1.8HashMap的put方法源碼以下:

public V put(K key, V value) {
      // 對key的hashCode()作hash
      return putVal(hash(key), key, value, false, true);
  }
  
  final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
      Node<K,V>[] tab; Node<K,V> p; int n, i;
      // 步驟1：tab爲空則建立
     if ((tab = table) == null || (n = tab.length) == 0)
         n = (tab = resize()).length;
     // 步驟2：計算index，並對null作處理 
     if ((p = tab[i = (n - 1) & hash]) == null) 
         tab[i] = newNode(hash, key, value, null);
     else {
         Node<K,V> e; K k;
         // 步驟3：節點key存在，直接覆蓋value
         if (p.hash == hash &&
             ((k = p.key) == key || (key != null && key.equals(k))))
             e = p;
         // 步驟4：判斷該鏈爲紅黑樹
         else if (p instanceof TreeNode)
             e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
         // 步驟5：該鏈爲鏈表
         else {
             for (int binCount = 0; ; ++binCount) {
                 if ((e = p.next) == null) {
                     p.next = newNode(hash, key,value,null);
                      //鏈表長度大於8轉換爲紅黑樹進行處理
                     if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st 
                         treeifyBin(tab, hash);
                     break;
                 }
                    // key已經存在直接覆蓋value
                 if (e.hash == hash &&
                     ((k = e.key) == key || (key != null && key.equals(k)))) 
							break;
                 p = e;
             }
         }
         
         if (e != null) { // existing mapping for key
             V oldValue = e.value;
             if (!onlyIfAbsent || oldValue == null)
                 e.value = value;
             afterNodeAccess(e);
             return oldValue;
         }
     }

     ++modCount;
     // 步驟6：超過最大容量 就擴容
     if (++size > threshold)
         resize();
     afterNodeInsertion(evict);
     return null;
 }複製代碼

HashMap 容許插入key爲 null 的鍵值對。可是由於沒法調用 null 的 hashCode() 方法，也就沒法肯定該鍵值對的桶下標，只能經過強制指定一個桶下標來存放。HashMap 使用第 0 個桶存放鍵爲 null 的鍵值對。

private V putForNullKey(V value) {
    for (Entry<K,V> e = table[0]; e != null; e = e.next) {
        if (e.key == null) {
            V oldValue = e.value;
            e.value = value;
            e.recordAccess(this);
            return oldValue;
        }
    }
    modCount++;
    addEntry(0, null, value, 0);
    return null;
}複製代碼

使用鏈表的頭插法，也就是新的鍵值對插在鏈表的頭部，而不是鏈表的尾部。

在jdk1.8以前是插入頭部的，在jdk1.8中是插入尾部的。

void addEntry(int hash, K key, V value, int bucketIndex) {
    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);
}

void createEntry(int hash, K key, V value, int bucketIndex) {
    Entry<K,V> e = table[bucketIndex];
    // 頭插法，鏈表頭部指向新的鍵值對
    table[bucketIndex] = new Entry<>(hash, key, value, e);
    size++;
}

Entry(int h, K k, V v, Entry<K,V> n) {
    value = v;
    next = n;
    key = k;
    hash = h;
}
複製代碼

2.3. 擴容-基本原理

擴容(resize)就是從新計算table桶容量，向HashMap對象裏不停的添加元素，而HashMap對象內部的數組沒法裝載更多的元素時，對象就須要擴大數組的長度，以便能裝入更多的元素。固然Java裏的數組是沒法自動擴容的，方法是使用一個新的數組代替已有的容量小的數組，就像咱們一個小教室只能坐一個班，若是想更多的學生進來聽課，就得換大教室上課。

和擴容相關的參數主要有：capacity、size、threshold 和 load_factor。數據結構

參數	含義
capacity	table 的容量大小，默認爲 16。須要注意的是 capacity 必須保證爲 2 的 n 次方。
size	table 的實際使用量。
threshold	size 的臨界值，size 必須小於 threshold，若是大於等於，就必須進行擴容操做。
loadFactor	裝載因子，table 可以使用的比例，threshold = capacity * loadFactor。

static final int DEFAULT_INITIAL_CAPACITY = 16;
static final int MAXIMUM_CAPACITY = 1 << 30;
static final float DEFAULT_LOAD_FACTOR = 0.75f;
transient Entry[] table;
transient int size;
int threshold;
final float loadFactor;
transient int modCount;複製代碼

從下面的添加元素代碼中能夠看出，當須要擴容時，令 capacity 爲原來的兩倍。

void addEntry(int hash, K key, V value, int bucketIndex) {
    Entry<K,V> e = table[bucketIndex];
    table[bucketIndex] = new Entry<>(hash, key, value, e);
    if (size++ >= threshold)
        resize(2 * table.length);
}複製代碼

擴容使用 resize() 實現，須要注意的是，擴容操做一樣須要把 oldTable 的全部鍵值對從新插入 newTable 中，所以這一步是很費時的。

咱們分析下resize的源碼，這裏使用的是JDK1.7的代碼，好理解一些，本質上區別不大。多線程

void resize(int newCapacity) {   //傳入新的容量
     Entry[] oldTable = table;    //引用擴容前的Entry數組
     int oldCapacity = oldTable.length;         
     if (oldCapacity == MAXIMUM_CAPACITY) {  //擴容前的數組大小若是已經達到最大(2^30)了
         threshold = Integer.MAX_VALUE; //修改閾值爲int的最大值(2^31-1)，這樣之後就不會擴容了
         return;
     }
  
     Entry[] newTable = new Entry[newCapacity];  //初始化一個新的Entry數組
    transfer(newTable);                         //將數據轉移到新的Entry數組裏
    table = newTable;                           //HashMap的table屬性引用新的Entry數組
    threshold = (int)(newCapacity * loadFactor);//修改閾值
}
複製代碼

這裏就是使用一個容量更大的數組來代替已有的容量小的數組，transfer()方法將原有Entry數組的元素拷貝到新的Entry數組裏。

void transfer(Entry[] newTable) {
    Entry[] src = table;                   //src引用了舊的Entry數組
    int newCapacity = newTable.length;
    for (int j = 0; j < src.length; j++) { //遍歷舊的Entry數組
        Entry e = src[j];       //取得舊Entry數組的每一個元素
        if (e != null) {
//釋放舊Entry數組的對象引用（for循環後，舊的Entry數組再也不引用任何對象）
            src[j] = null;
            do {
                Entry next = e.next;
                //！！從新計算每一個元素在數組中的位置
               int i = indexFor(e.hash, newCapacity);
               e.next = newTable[i]; //標記[1]
               newTable[i] = e;      //將元素放在數組上
               e = next;             //訪問下一個Entry鏈上的元素
           } while (e != null);
       }
   }
} 複製代碼

其實上面的數組擴容、從新計算下標值並將舊數據插入到新數組的過程並不難，有意思的一點是JDK1.8在這裏對擴容後的元素移動操做作了優化，具體過程以下。

通過觀測能夠發現，咱們使用的是2次冪的擴展(指長度擴爲原來2倍)，因此，元素的位置要麼是在原位置，要麼是在原位置再移動2次冪的位置。

看下圖能夠明白這句話的意思，n爲table的長度，圖（a）表示擴容前的key1和key2兩種key肯定索引位置的示例，圖（b）表示擴容後key1和key2兩種key肯定索引位置的示例，其中hash1是key1對應的哈希與高位運算結果。

元素在從新計算hash以後，由於n變爲2倍，那麼n-1的範圍在高位多1bit(紅色)，所以新的index就會發生這樣的變化：

所以，咱們在擴充HashMap的時候，不須要像JDK1.7的實現那樣從新計算hash，只須要看看原來的hash值新增的那個bit是1仍是0就行了，是0的話索引沒變，是1的話索引變成「原索引+oldCap」。

具體細節你們不妨能夠去看看JDK1.8的源碼中resize是怎麼寫的，這個思路的確十分巧妙。

3. 爲何HashMap線程不安全？

在多線程使用場景中，應該儘可能避免使用線程不安全的HashMap，而使用線程安全的ConcurrentHashMap。那麼爲何說HashMap是線程不安全的，下面舉例子說明在併發的多線程使用場景中使用HashMap可能形成死循環。代碼例子以下(便於理解，仍然使用JDK1.7的環境)：

public class HashMapInfiniteLoop {  
    private static HashMap map = new HashMap(2，0.75f);  
    public static void main(String[] args) {  
        map.put(5， "C");  
        new Thread("Thread1") {  
            public void run() {  
                map.put(7, "B");  
                System.out.println(map);  
            };  
        }.start();  
        new Thread("Thread2") {  
            public void run() {  
                map.put(3, "A);  
                System.out.println(map);  
            };  
        }.start();        
    }  
} 複製代碼

其中，map初始化爲一個長度爲2的數組，loadFactor=0.75，threshold=2*0.75=1，也就是說當put第二個key的時候，map就須要進行resize。

經過設置斷點讓線程1和線程2同時debug到transfer方法(3.3小節代碼塊)的首行。注意此時兩個線程已經成功添加數據。放開thread1的斷點至transfer方法的「Entry next = e.next;」這一行；而後放開線程2的的斷點，讓線程2進行resize。結果以下圖。

注意，Thread1的 e 指向了key(3)，而next指向了key(7)，其在線程二rehash後，指向了線程二重組後的鏈表。

線程一被調度回來執行，先是執行 newTalbe[i] = e，而後是e = next，致使了e指向了key(7)，而下一次循環的next = e.next致使了next指向了key(3)。

e.next = newTable[i] 致使 key(3).next 指向了 key(7)。注意：此時的key(7).next 已經指向了key(3)，環形鏈表就這樣出現了。

因而，當咱們用線程一調用map.get(11)時，就會發現問題，進入一個死循環了。

4. 與 HashTable 的比較

hashmap不是線程安全的、hashtable是安全的
HashMap容許將 null 做爲一個 entry 的 key 或者 value，而 Hashtable 不容許。
HashMap 把 Hashtable 的 contains 方法去掉了，改爲 containsValue 和 containsKey。由於 contains 方法容易讓人引發誤解。
HashTable 繼承自 Dictionary 類，而 HashMap 是 Java1.2 引進的 Map interface 的一個實現。
HashTable 的方法是 Synchronized 的，而 HashMap 不是，在多個線程訪問 Hashtable 時，不須要本身爲它的方法實現同步，而 HashMap 就必須爲之提供外同步，或者改成使用ConcurrentHashMap。
Hashtable 和 HashMap 採用的 hash/rehash 算法都大概同樣，因此性能不會有很大的差別。
HashMap 不能保證隨着時間的推移 Map 中的元素次序是不變的。
HashMap 的迭代器是 fail-fast 迭代器。