HashTable的故事----Jdk源碼解讀

HashTable的故事

很早以前，在講HashMap的時候，咱們就說過hash是散列，把...弄碎的意思。hashtable中的hash也是這個意思，而table呢，是指數據表格，也就是說hashtable的本意是指，一份被數據被打散，分散在各處的數據表格。

HashTable，做爲jdk中，極早提供的容器類（jdk1.0），同時是支持數據併發的類，其在項目中的使用卻並非很普遍。在我所經歷的項目中，開發人員每每喜歡使用hashMap而後再經過鎖，創造出線程安全的環境。即便是後來推出concurrentHashMap，其使用的地方也並無特別普遍。究其緣由，我以爲是因爲開發人員對於其餘hash容器並不熟悉。更願意使用已有的較爲熟悉的hash容器，即便他們在此處的應用比較費事。

好了，廢話很少說，咱們直接開始進入正題吧：

hashTable繼承自dic類，同時實現了map接口和Cloneable、Serializable兩個接口，表明該類是可複製、序列化的類。

public class Hashtable<K,V>
    extends Dictionary<K,V>
    implements Map<K,V>, Cloneable, java.io.Serializable

ps：dic類和map類較爲類似，是一個抽象的hash映射類，包含了一些簡單的空方法和接口。

private transient Entry<?,?>[] table;

瞬時數組變量，它就是hashtable中，最核心的數據存儲區域。

 

    /** * The total number of entries in the hash table. */
    private transient int count;

數組長度，不知道你們發現沒有，jdk很是喜歡用一個獨立變量來表示容器中數據的大小，而不是每次返回核心數據的size或length。

 

閾值，這個以前專門強調過，這裏簡單說下，他是容積和負載因子的乘積，表示的含義是當前容器中，能表現出較好性能的數據量上限。超過這個上限時，容器的性能將會有比較大的降低。注意容積和閾值是有區別的。

threshold  ['θrɛʃhold]  n. 入口；門檻；開始；極限；臨界值 

   private int threshold;

負載因子，是用來設定當前容器中，元素的填充率的。

你能夠理解成容器是一個城市，這個城市中最佳入住率的一個上限是負載因子。這個城市的入住用戶最佳的數目，就是他的閾值。

    /** * The load factor for the hashtable. * * @serial
     */
    private float loadFactor;

接下來是modCount ，這個變量的意義是，記錄hashtable中，被修改的次數（包括增、刪、改）三個操做的。而其用途呢，是將來被用做斷定快速失敗時（fail-fast）的依據數據。關於快速失敗，這個我會在下邊講到。你們這裏只要知道modCount這個變量的表示的含義是什麼就能夠。

    private transient int modCount = 0;

而後是版本序列號

    private static final long serialVersionUID = 1421746759512286392L;

接着是構造函數，參數分別爲初始容積和負載因子。

函數內會首先判斷初始容積和負載因子是否爲正數。

接着若是初始容積爲0，則賦予默認值1.也就是說，真實的容積至少都要爲1。

接着對table賦予初始值，一個長度爲初始容積大小的Entry數組。(防盜鏈接：本文首發自http://www.cnblogs.com/jilodream/ )接着計算

閾值=（初始容積和負載因子的乘積），（當前系統中最大的數組長度+1），兩者的最小值。

也就是說閾值不能超過數組的最大長度+1。這裏注意一個isNaN()方法,是個頗有意思的方法，研究該方法的源碼後，你會以爲頗有意思。這個我會在之後的文章中講到。

public Hashtable(int initialCapacity, float loadFactor) { if (initialCapacity < 0) throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity); if (loadFactor <= 0 || Float.isNaN(loadFactor)) throw new IllegalArgumentException("Illegal Load: "+loadFactor); if (initialCapacity==0) initialCapacity = 1; this.loadFactor = loadFactor; table = new Entry<?,?>[initialCapacity]; threshold = (int)Math.min(initialCapacity * loadFactor, MAX_ARRAY_SIZE + 1); }

只要初始容積的構造函數，負載因子默認爲0.75

    public Hashtable(int initialCapacity) { this(initialCapacity, 0.75f); }

無參的構造函數，初始容積使用爲11，負載因子爲0.75

    public Hashtable() { this(11, 0.75f); }

不知道你們發現沒，儘管提供了一個可能的，可是jdk的源碼每每系統提供多個，應用於不一樣場景的接口，這些接口每每其實只是對自身其餘接口的一個適配。可是對於調用者來講，這樣卻很舒服。

 

接着是最後一個構造函數，參數爲一個map，map的k，v分別繼承自hashTable中的K,V.

函數首先調用一遍通用的構造函數，負載因子爲0.75。初始容積爲map長度的兩倍以及默認的11，兩者的較大值。也就是說對於初始容積來講，最小都要取到11。

接着調用putAll方法，將map中的數據添加到HashTable中。

    public Hashtable(Map<? extends K, ? extends V> t) { this(Math.max(2*t.size(), 11), 0.75f); putAll(t); }

size()方法，方法採用同步機制，返回count變量。因爲容器中並非全部的元素都佔滿了數據，因此直接用變量返回值的速度和效率會更高點。同時因爲count會隨時變更，這裏採用同步方法的形式進行線程保護。

    public synchronized int size() { return count; }

isEmpyt，判斷當前數組是否爲空，與size()方法一致。

    public synchronized boolean isEmpty() { return count == 0; }

keys，elements方法，分別返回返回hashTable中全部的key和value的枚舉集合。

這裏KEYS，VALUES爲靜態int常量。getEnumeration在下文中會提到。另外與前邊的方法相同，這裏也是對整個方法進行同步加鎖。

    public synchronized Enumeration<K> keys() { return this.<K>getEnumeration(KEYS); } public synchronized Enumeration<V> elements() { return this.<V>getEnumeration(VALUES); }

 接着是contains方法，方法意義再也不贅述。

實現邏輯，首先判斷value是否爲null，若是爲null則直接拋出空引用。

接着將table變量賦值給tab臨時變量。而後循環tab，依次取出tab中的entry，以及entry的後繼元素。(防盜鏈接：本文首發自http://www.cnblogs.com/jilodream/ )若是元素的value equals()判斷等於參數value，則直接返回true。整個方法結束後，爲發現，則會返回false。同時方法自己也是加同步鎖進行線程安全保護。

    public synchronized boolean contains(Object value) { if (value == null) { throw new NullPointerException(); } Entry<?,?> tab[] = table; for (int i = tab.length ; i-- > 0 ;) { for (Entry<?,?> e = tab[i] ; e != null ; e = e.next) { if (e.value.equals(value)) { return true; } } } return false; }

接着是實現map接口的抽象方法，只是對contains方法進行了一層封裝。

    public boolean containsValue(Object value) { return contains(value); }

接着是線程同步方法：containsKey，方法含義不贅述，邏輯以下：

設定臨時變量並賦值table。取出key的hashCode。注意這裏並無斷定key是否爲null。

而前文中的value則是斷定的。這是因爲value是做爲equals方法的參數的。即便是null也沒法被發現，可是斷定一個映射的value爲null表示的真的爲null仍是沒有映射到，這很歧義，因此乾脆直接拋出異常。回到正文，根據hashCode計算出其在table數組中的索引。其實就是取低8位數字而後除以數組length取餘數。(防盜鏈接：本文首發自http://www.cnblogs.com/jilodream/ )

接着依次循環table該索引的後繼元素，斷定是否equals()相等。若是有則返回true。若是始終沒有找到，則返回false。

    public synchronized boolean containsKey(Object key) { Entry<?,?> tab[] = table; int hash = key.hashCode(); int index = (hash & 0x7FFFFFFF) % tab.length; for (Entry<?,?> e = tab[index] ; e != null ; e = e.next) { if ((e.hash == hash) && e.key.equals(key)) { return true; } } return false; }

get()方法，與containsKey方法的邏輯是一致的。不一樣點是，在返回結果是，若是確實存在該key，則返回對應的value，不然返回null。

    public synchronized V get(Object key) { Entry<?,?> tab[] = table; int hash = key.hashCode(); int index = (hash & 0x7FFFFFFF) % tab.length; for (Entry<?,?> e = tab[index] ; e != null ; e = e.next) { if ((e.hash == hash) && e.key.equals(key)) { return (V)e.value; } } return null; }

接着是前文提到的數組最大數字常亮。這裏注意看參數的註釋。部分虛擬機是設定數組的長度限制的。若是超出，可能會致使OOM異常

    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

接着是rehash方法。這個方法是一個受保護方法。會在接下來的，hashtable添加元素的場景中被調用。他的做用呢，就是從新申請一塊大小合適的內存。而後將鍵值元素從新安置到這塊元素中。

那麼就須要兩個步驟。

一、計算新內存的大小。

二、計算元素在新table中的位置。

    先看代碼：

 1     protected void rehash() {  2         int oldCapacity = table.length;  3         Entry<?,?>[] oldMap = table;  4 
 5         // overflow-conscious code
 6         int newCapacity = (oldCapacity << 1) + 1;  7         if (newCapacity - MAX_ARRAY_SIZE > 0) {  8             if (oldCapacity == MAX_ARRAY_SIZE)  9                 // Keep running with MAX_ARRAY_SIZE buckets
10                 return; 11             newCapacity = MAX_ARRAY_SIZE; 12  } 13         Entry<?,?>[] newMap = new Entry<?,?>[newCapacity]; 14 
15         modCount++; 16         threshold = (int)Math.min(newCapacity * loadFactor, MAX_ARRAY_SIZE + 1); 17         table = newMap; 18 
19         for (int i = oldCapacity ; i-- > 0 ;) { 20             for (Entry<K,V> old = (Entry<K,V>)oldMap[i] ; old != null ; ) { 21                 Entry<K,V> e = old; 22                 old = old.next; 23 
24                 int index = (e.hash & 0x7FFFFFFF) % newCapacity; 25                 e.next = (Entry<K,V>)newMap[index]; 26                 newMap[index] = e; 27  } 28  } 29     }

代碼中會首先獲取舊table的長度oldCapacity 。而後oldCapacity 乘以2再加1.算出新table的長度newCapacity 。

接着判斷newCapacity 是否超出了hashtable所能設定的最大值：MAX_ARRAY_SIZE。若是超出，則判斷oldCapacity 是否已經等於最大值。若是已經等於，則認定，當前hashtable的長度已經到達所容許的上限。沒法再繼續擴容。則直接返回。

不然將MAX_ARRAY_SIZE賦值給newCapacity 。做爲新的長度。也就是說rehash在大小容許的狀況下，通常會翻倍擴容。可是若是翻倍後長度超出上限，則以上限大小做爲擴容後新的大小。

接着以newCapacity 做爲長度，new出一個Entry數組，做爲新的table元素存放容器。

modCount自加1。

接着計算閾值：newCapacity 乘以負載因子和MAX_ARRAY_SIZE+1 取較小值。注意這裏負載因子是能夠大於1的。所以newCapacity 乘以負載因子，式能夠大於MAX_ARRAY_SIZE的。

接着就是計算舊有table中的鍵值元素在新table中的位置了：這裏使用的是雙層循環，外層依次遍歷Entry主數組上的元素。若是entry[i]不等於null值，則將該元素及其後繼元素依次計算出新的位置，而後插入到主數組上的對應位置。同時將主數組中原來位置的元素。做爲新放置元素的後繼。也就是每一個新元素，插在每一個對應位置的鏈表最前側。至於爲何不放在這個對應鏈表的最後位置。其實很簡單，由於這是一個鏈式存儲結構，須要依次遍歷每一個元素，才能找到隊尾的元素。

接着是添加元素的私有方法addEntry。(防盜鏈接：本文首發自http://www.cnblogs.com/jilodream/ )

首先是modCount自加1.

接着若是當前table的數量已經超過了閾值，那麼就進行一次rehash，接着根據key的hashCode計算出當前鍵值對的輸入索引。接着取出table對應索引位置的元素一同作出一個新的Entry元素放在這個對應索引的位置上。（這裏要注意後續的entry 的構造方法）同時count數目自加1。這裏須要注意的是，當前數目若是已經超過閾值，前邊講到的rehash是不必定會從新作出新數組的（length超過了MAX_ARRAY_SIZE的限制時）不少人在理解這裏的時候，就認定只要count超過閾值就必定會從新分配table內存的地址，這個理解是存在問題的。

 1     private void addEntry(int hash, K key, V value, int index) {  2         modCount++;  3 
 4         Entry<?,?> tab[] = table;  5         if (count >= threshold) {  6             // Rehash the table if the threshold is exceeded
 7  rehash();  8 
 9             tab = table; 10             hash = key.hashCode(); 11             index = (hash & 0x7FFFFFFF) % tab.length; 12  } 13 
14         // Creates the new entry.
15         @SuppressWarnings("unchecked") 16         Entry<K,V> e = (Entry<K,V>) tab[index]; 17         tab[index] = new Entry<>(hash, key, value, e); 18         count++; 19     }

接着是put方法。這個方法是hashtable很是經常使用的一個public方法。方法自己是一個同方法。在方法中對於參數value和key有邏輯：若是爲null時，均會報出空引用異常。

 1     public synchronized V put(K key, V value) {  2         // Make sure the value is not null
 3         if (value == null) {  4             throw new NullPointerException();  5  }  6 
 7         // Makes sure the key is not already in the hashtable.
 8         Entry<?,?> tab[] = table;  9         int hash = key.hashCode(); 10         int index = (hash & 0x7FFFFFFF) % tab.length; 11         @SuppressWarnings("unchecked") 12         Entry<K,V> entry = (Entry<K,V>)tab[index]; 13         for(; entry != null ; entry = entry.next) { 14             if ((entry.hash == hash) && entry.key.equals(key)) { 15                 V old = entry.value; 16                 entry.value = value; 17                 return old; 18  } 19  } 20 
21  addEntry(hash, key, value, index); 22         return null; 23     }

接着算出key所應該對應的主數組的索引。循環遍歷出該數組元素所對應的隊列（tab[index]）,若是元素的hash值等於新添加元素的hash，同時entry的key等於（equals）key方法。則直接替換這個entry的value爲參數傳入的value，與此同時返回舊old。

若是整個循環都發現沒有，則說明當前hashtable其實並不存在該參數key，則調用剛纔說的addEntry方法，將參數key value，及對應的索引傳進去。這裏注意put方法爲同步公有方法，而addEntry爲私有非同步方法，這裏是否存在線程安全問題呢？(防盜鏈接：本文首發自http://www.cnblogs.com/jilodream/ )其實並不存在，這是因爲addEntry儘管會操做全局變量主數組，可是addEntry方法只會被put方法調用。而凡是調用put方法的線程均須要先拿到this變量鎖。儘管再次進去無同步的addEntry的方法區，當前線程仍然持有this變量鎖，其餘線程若想操做全局變量主數組，仍然須要等待全局鎖的釋放才能夠。

接着是remove方法。該方法邏輯以下：首選根據key值計算出元素所對應主數組中的索引位置。而後依次循環主數組下該索引對應元素的後繼元素。判斷該元素的hash是否等於key參數的hash，以及元素是否equels參數key。若是相等，則將該元素從隊列中抹除。同時hashtable的長度count 減1，同時modCount值也自加1。若是循環結束仍未找到合適的元素與參數key相等，則返回null

 

 1     public synchronized V remove(Object key) {  2         Entry<?,?> tab[] = table;  3         int hash = key.hashCode();  4         int index = (hash & 0x7FFFFFFF) % tab.length;  5         @SuppressWarnings("unchecked")  6         Entry<K,V> e = (Entry<K,V>)tab[index];  7         for(Entry<K,V> prev = null ; e != null ; prev = e, e = e.next) {  8             if ((e.hash == hash) && e.key.equals(key)) {  9                 modCount++; 10                 if (prev != null) { 11                     prev.next = e.next; 12                 } else { 13                     tab[index] = e.next; 14  } 15                 count--; 16                 V oldValue = e.value; 17                 e.value = null; 18                 return oldValue; 19  } 20  } 21         return null; 22     }

接着是putAll方法，該方法會將map集合中的對象，採用foreach的形式，依次調用put方法添加到hashtable集合中。

    public synchronized void putAll(Map<? extends K, ? extends V> t) { for (Map.Entry<? extends K, ? extends V> e : t.entrySet()) put(e.getKey(), e.getValue()); }

接着是clear方法。該方法首先將modCount加1.接着循環主數組中的全部元素，而後依次對這些元素置於null。而後設定count元素爲0。這裏有一點須要注意，即clear時，只清理了主數組中的元素。對於主數組中對應元素的後繼列表，則採用不予理會的態度。等待GC來回收掉。

1     public synchronized void clear() { 2         Entry<?,?> tab[] = table; 3         modCount++; 4         for (int index = tab.length; --index >= 0; ) 5             tab[index] = null; 6         count = 0; 7     }

接着是clone方法。該方法會克隆一個自身對象的副本。此方法會克隆出一個空的hashtable。而後將主數組中的全部元素克隆一遍，放置到克隆對象的對應位置上。注意在克隆元素的時候，會將元素的後繼隊列元素，依次的克隆下去。接着初始化克隆對象的其餘變量：置空keyset、entryset、values對象，設置modCount爲0。

 1     public synchronized Object clone() {  2         try {  3             Hashtable<?,?> t = (Hashtable<?,?>)super.clone();  4             t.table = new Entry<?,?>[table.length];  5             for (int i = table.length ; i-- > 0 ; ) {  6                 t.table[i] = (table[i] != null)  7                     ? (Entry<?,?>) table[i].clone() : null;  8  }  9             t.keySet = null; 10             t.entrySet = null; 11             t.values = null; 12             t.modCount = 0; 13             return t; 14         } catch (CloneNotSupportedException e) { 15             // this shouldn't happen, since we are Cloneable
16             throw new InternalError(e); 17  } 18     }

而後是重寫的tostring方法。這個方法邏輯也很簡單，就是依次遍歷元素。最後生成一個相似於{「key1」=」value1」,「key2」=」value2」}的結構。有趣的是這裏須要調用key.tostring，假若key是當前hashtable本身的話，就直接使用「(this map)」字符串。防止出現無限遞歸。

 1     public synchronized String toString() {  2         int max = size() - 1;  3         if (max == -1)  4             return "{}";  5 
 6         StringBuilder sb = new StringBuilder();  7         Iterator<Map.Entry<K,V>> it = entrySet().iterator();  8 
 9         sb.append('{'); 10         for (int i = 0; ; i++) { 11             Map.Entry<K,V> e = it.next(); 12             K key = e.getKey(); 13             V value = e.getValue(); 14             sb.append(key   == this ? "(this Map)" : key.toString()); 15             sb.append('='); 16             sb.append(value == this ? "(this Map)" : value.toString()); 17 
18             if (i == max) 19                 return sb.append('}').toString(); 20             sb.append(", "); 21  } 22     }

到這裏hashtable的主要邏輯就已經都介紹完了。其他還包括一些keyset、valueSet的內部類、以及replaceAll、putIfAbsent等封裝方法。因爲代碼邏輯簡單，數量較大，這裏就不一一列舉了。

總結：

一、Hashtable包括tostirng等方法在，幾乎全部對外api方法都是同步保護的，這就是爲何不少人認爲hashtable線程安全的緣由。而在基礎上，對於同步方法所調用的private方法，則大多采用非同步的形式。由於這些方法，每每只有一個public方法能夠調用，這樣就作到了在安全的基礎上能夠更快執行代碼。

二、hashtable的內部結構大體以下，和早前的hashmap很像：

三、關於元素的取值，hashtable不容許key和value取值爲null。因此get時，發現爲null，即說明key元素不存在。同時hashtable在擴容是採用的是乘2加1的方式。這與有些容器直接乘2有所區別。

四、關於變量modCount的使用。咱們能夠看到這個方法中，每次在發生增刪改的時候都會出現modCount++的動做。而modcount能夠理解爲是當前hashtable的狀態。每發生一次操做，狀態就向前走一步。(防盜鏈接：本文首發自http://www.cnblogs.com/jilodream/ )設置這個狀態，主要是因爲hashtable等容器類在迭代時，判斷數據是否過期時使用的。儘管hashtable採用了原生的同步鎖來保護數據安全。可是在出現迭代數據的時候，則沒法保證邊迭代，邊正確操做。因而使用這個值來標記狀態。一旦在迭代的過程當中狀態發生了改變，則會快速拋出一個異常，終止迭代行爲（因此這種錯誤也叫作快速失敗fail—fast）：

            if (modCount != expectedModCount) throw new ConcurrentModificationException();

因爲工做中存在一些變更，因此這篇文章拖了好久才寫完。在寫的過程當中，發現越後邊越細。越寫愈加現本身離王垠所寫的編程學習越遠（可搜索《如何掌握全部的程序語言》）。由於最後認爲不少源碼邏輯簡單冗餘也就再也不贅述了，這也是後續我對java及其它技術學習以及博客總結的一個指向吧。