問題
在併發的情況下hashMap除了會造成數據的髒讀外在jdk1.8之前還會造成死鎖
原因
主要原因是,使用頭插法。但是在jdk1.8及之後時,使用的是數組+鏈表+紅黑樹的數據結構(當鏈表的深度達到8的時候,也就是默認閾值,就會自動擴容把鏈表轉成紅黑樹的數據結構來把時間複雜度從O(n)變成O(logN)提高了效率),使用尾插法
分析原因
在jdk1.8之前使用的是數組+單鏈表的數據結構會先進行擴容再插入,執行的是頭插法,先將原位置的數據移到後一位,再插入數據到該位置;會出現逆序和環形鏈表死循環問題
在jdk1.8及之後時,使用的是數組+鏈表+紅黑樹的數據結構(當鏈表的深度達到8的時候,也就是默認閾值,就會自動擴容把鏈表轉成紅黑樹的數據結構來把時間複雜度從O(n)變成O(logN)提高了效率),會先進行插入再進行擴容,執行的是尾插法,直接插到鏈表尾部/紅黑數樹,不會出現逆序和環形鏈表死循環問題
jdk1.8之前
jdk1.8之前的源碼
public V put(K key, V value) {
if (table == EMPTY_TABLE) {
inflateTable(threshold);
}
if (key == null)
return putForNullKey(value);
int hash = hash(key);
int i = indexFor(hash, table.length);
//如果key存在,就替換
for (Entry<K,V> e = table[i]; e != null; e = e.next) {
Object k;
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
modCount++;
//如果key不存在就插入一個新元素
addEntry(hash, key, value, i);
return null;
}
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 resize(int newCapacity) {
Entry[] oldTable = table;
int oldCapacity = oldTable.length;
if (oldCapacity == MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return;
}
//創建一個新的 Hash 表
Entry[] newTable = new Entry[newCapacity];
//轉移的方法
transfer(newTable, initHashSeedAsNeeded(newCapacity));
table = newTable;
threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
}
//轉移數據的具體步驟
void transfer(Entry[] newTable, boolean rehash) {
int newCapacity = newTable.length;
for (Entry<K,V> e : table) {
while(null != e) {
Entry<K,V> next = e.next;
if (rehash) {
e.hash = null == e.key ? 0 : hash(e.key);
}
int i = indexFor(e.hash, newCapacity);
e.next = newTable[i];
newTable[i] = e;
e = next;
}
}
}
可以看見進行轉移數據時執行的是頭插法,如果轉移前鏈表順序是1->2->3,那麼轉移後就會變成3->2->1。所以,在併發的情況下就可能會導致1->2的同時2->1的情況從而導致環形鏈表出現。
舉一個例子:三個線程A、B、C
1.兩個線程A、B同時執行了transfer方法
2.線程A執行完Entry<K,V> next = e.next;後被掛起,然後線程B執行完整個方法,此時線程B的鏈表是3->2->1,e是1 next是2。
3.繼續執行線程A執行完一個while循環後,e=2,線程A的鏈表是1
4.繼續執行線程A,此時e=2且2->1,所以next=1,執行一個while循環後,e=1,線程A的鏈表是2->1。
4.繼續執行線程A,此時e=1,所以next=null,執行一個while循環後,e=null,線程A的鏈表是1->2->1,環形鏈表出現。
5.程序繼續執行。
6.此時線程C執行get方法,get會調用getEntry(),這個函數就是去找對應索引的鏈表中有沒有這個key。然後因爲環形鏈表的原因從而導致死循環。
jdk1.8
jdk1.8的源碼
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;
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
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) // -1 for 1st
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;
}
在jdk1.8中當鏈表長度大於8是會被轉化成紅黑樹,大量的if-else判斷是爲了處理紅黑樹的情況的,與鏈表插入相關的核心代碼只有如下幾行:
for (int binCount = 0; ; ++binCount) {
//e是p的下一個節點
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在鏈表中已經存在,則退出循環
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
//如果key在鏈表中已經存在,則修改其原先的key值,並且返回老的值
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
從這段代碼中可以很顯然地看出當到達鏈表尾部(即p是鏈表的最後一個節點)時,e被賦爲null,會進入這個分支代碼,然後會用newNode方法建立一個新的節點插入尾部,這樣就不會造成環形鏈表。