談談HashMap與HashTable HashMap 我們一直知道HashMap是非線程安全的，HashTable是線程安全的，可這是為什麼呢？先聊聊HashMap吧，想要瞭解它為什麼是非線程安全的，我們得從它的原理著手。 jdk7中的HashMap HashMap底層維護一個數組，數組中的每一項 ...
談談HashMap與HashTable
HashMap
我們一直知道HashMap是非線程安全的，HashTable是線程安全的，可這是為什麼呢？先聊聊HashMap吧，想要瞭解它為什麼是非線程安全的，我們得從它的原理著手。
jdk7中的HashMap
HashMap底層維護一個數組，數組中的每一項都是Entry
transient Entry<K,V>[] table;我們向HashMap放置的對象實際上是放置在Entry數組中
而Map中的key、value則以Entry的形式存放在數組中
private static class Entry<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
Entry<K,V> next;而這個Entry應該放在數組的哪一個位置上（這個位置通常稱為位桶或者hash桶，即hash值相同的Entry會放在同一位置，用鏈表相連），是通過key的hashCode來計算的。
當兩個key通過hashcode計算是相同的時候，就會發生hash衝突，HashMap解決hash衝突的辦法是使用鏈表。
簡而言之就是，如果該位置沒有對象，則將對象直接放到數組中，如果該位置有對象，順著存在此對象的鏈找（Map中不允許存在相同的key和value），如果不存在相同的，第一種情況：如果該鏈表擴容了，則把對象放入到數組中，原先存放在數組中的數據放置該對象的後面。第二種情況：如果該鏈表沒有擴容，則直接放到鏈表的最後。如果存在相同的，則進行替換。
當HashMap中的元素越來越多的時候，hash衝突的幾率也就越來越高，因為數組的長度是固定的。所以為了提高查詢的效率，就要對HashMap的數組進行擴容，而在HashMap數組擴容之後，最消耗性能的點就出現了：原數組中的數據必須重新計算其在新數組中的位置，並放進去，這就是resize。
值得註意的是，HashMap中key和value都允許有null值存在，不過只允許一個null的key，可以有多個null值的value。
jdk8中的HashMap
在JDK1.7的部分就只有鏈表結構，但是由於鏈表過長的時候查找元素時間較長，在JDK1.8的時候加入了紅黑樹，當鏈表超過一定長度之後，鏈表就會轉換成紅黑樹，便於查找和插入，在最壞的情況下，鏈表的時間複雜度是O(n),紅黑樹是O(logn),這樣會提高HashMap的效率。
在jdk8中，當同一個hash值得節點數大於8的時候，將不再以鏈表的形式存儲了，而是會調整成一顆紅黑樹。
static final int TREEIFY_THRESHOLD = 8;從JDK1.8開始，HashMap的元素是以Node形式存在，主要結構如下：
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
Node<K,V> next;
JDK中Entry的名字變成了Node，原因是和紅黑樹的實現TreeNode相關聯。
可以看一下jdk8中的put方法，跟jdk7相比還是做了很大的改變。
public V put(K key, V value) {
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;
//如果當前map中無數據，執行resize方法。並且返回n
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//如果要插入的鍵值對要存放的這個位置剛好沒有元素，那麼把他封裝成Node對象，放在這個位置上就可以了
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
//如果這個元素的key與要插入的一樣，那麼就替換一下
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
//如果當前節點是TreeNode類型的數據，存儲的鏈表已經變為紅黑樹了，執行putTreeVal方法去存入
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
//還是鏈表狀態
else {
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
//判斷是否要轉成紅黑樹
if (binCount >= TREEIFY_THRESHOLD - 1)
treeifyBin(tab, hash);
break;
}
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;
//判斷閥值，決定是否擴容
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}HashMap的多線程不安全
個人覺得HashMap在併發時可能出現的問題主要是兩方面,首先如果多個線程同時使用put方法添加元素，而且假設正好存在兩個put的key發生了碰撞(hash值一樣)，那麼根據HashMap的實現，這兩個key會添加到數組的同一個位置，這樣最終就會發生其中一個線程的put的數據被覆蓋。第二就是如果多個線程同時檢測到元素個數超過數組大小*loadFactor，這樣就會發生多個線程同時對Node數組進行擴容，都在重新計算元素位置以及複製數據，但是最終只有一個線程擴容後的數組會賦給表，也就是說其他線程的都會丟失，並且各自線程put的數據也丟失。
對第二種不安全的情況進行分析：HashMap的死迴圈
由於插入過程，新插入元素總是插入到頭部，源碼如下：
void transfer(Entry[] newTable) {
Entry[] src = table;
int newCapacity = newTable.length;
for (int j = 0; j < src.length; j++) {
Entry<K,V> e = src[j];
if (e != null) {
src[j] = null;
//這裡在做插入的過程中，總是將新插入元素放在鏈表頭
do {
Entry<K,V> next = e.next;
int i = indexFor(e.hash, newCapacity);
e.next = newTable[i];
newTable[i] = e;
e = next;
} while (e != null);
}
}
}解析代碼：
e=3
Entry<K,V> next = e.next; 保存了3.next也就是7
e.next = newTable[i]; 表示3後面跟著的是null，newTable表示重新建立的一張表
newTable[i] = e; 表示在表的下標的那個位置放的是e(也就是3)，也就說下圖中的下標為3的地方放了key=3這個對象
e=next；表示e=7了第二次迴圈--
Entry<K,V> next = e.next; 保存了7.next也就是5
e.next = newTable[i]; 表示7.next=3了，說明3放到7的尾巴上去了
newTable[i] = e; 表示下圖中的下標為3的地方放了key=7這個對象
e=next；表示e=5了又開啟了再一次的迴圈。
為什麼會發生死迴圈呢？
解析：多線程情況下，多個線程同時檢測到對數組進行擴容
當線程1正好插入了3（e=3），並且保存了e.next(也就7)
CPU正好切到了線程2，並且完成了擴容，如上圖所示。
之後我們對線程1繼續進行操作，把7也插進線程1中，可以看到如下所示：
但是由於受到線程2的影響，e=7,e.next=3,我們後面又得插入3了，然後插入3之後，因為3.next=7,所以我們又插入7，這樣就形成了死迴圈。
這個問題在JDK1.8中得到瞭解決，它用了新的索引插入方式
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
do {
next = e.next;
//還是原索引位置
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
//原索引+ oldCap位置
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
} 由於擴容是在原容量基礎上乘以2，那麼hash碼校驗的時候會比原來的多一位，那麼只需要比較這個位置是0還是1即可，是1那麼就在原索引位置向後位移原容量大小即可，是0就不動。
HashTable
Hashtable是線程安全的，我們可以看看它的源碼
public synchronized V put(K key, V value) {
// Make sure the value is not null
if (value == null) {
throw new NullPointerException();
}
// Makes sure the key is not already in the hashtable.
Entry<?,?> tab[] = table;
int hash = key.hashCode();
int index = (hash & 0x7FFFFFFF) % tab.length;
@SuppressWarnings("unchecked")
Entry<K,V> entry = (Entry<K,V>)tab[index];
for(; entry != null ; entry = entry.next) {
if ((entry.hash == hash) && entry.key.equals(key)) {
V old = entry.value;
entry.value = value;
return old;
}
}
addEntry(hash, key, value, index);
return null;
}在主要的函數上都加了synchronize同步關鍵字，所有線程競爭同一把鎖，所以線程安全。
