相信很多人都知道jdk7及其以前版本的hashmap在併發場景下使用時存在死循環（注意是死循環，不是死鎖）的問題，問題出在擴容時對鏈表逆序的問題，下面是出問題的相關源碼：
/**
* Transfers all entries from current table to newTable.
*/
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;
}
}
}
jdk8對這一問題做了相關補救工作，不會出現死循環
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;
//oldCap代表有沒有數據插入，table創建採用lazy模式，只有使用時才創建
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
int newCap, newThr = 0;
if (oldCap > 0) { //已經有數據，證明不是初始化
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)//老的threshold大於16時，新的threshold才進行double處理
newThr = oldThr << 1; // double threshold
}//oldCap == 0，初始化，創建hashmap時沒有設置capacity
else if (oldThr > 0) // initial capacity was placed in threshold
//oldThr > 0 && oldCap == 0
newCap = oldThr;
else { // zero initial threshold signifies using defaults
//oldThr == 0 && oldCap == 0，初始化
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
if (newThr == 0) {//
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
threshold = newThr;
@SuppressWarnings({"rawtypes","unchecked"})
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
if (oldTab != null) {//插入數據時擴容
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) {//該散列桶已有數據，需要將該散列桶中數據重新映射
oldTab[j] = null;
if (e.next == null)//只有一個數據
newTab[e.hash & (newCap - 1)] = e;
else if (e instanceof TreeNode)//該散列桶中數據紅黑樹存儲
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { // preserve order 保證原來的順序，否則在多線程誤用時會導致死循環
//有多個數據，而且是鏈表形式存儲
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
do {
next = e.next;
/**
* 該hash在老哈希桶數組位置爲(oldCap-1) & hash，在擴容後哈希桶下標爲(2*oldCap-1) & hash
* 2*oldCap-1相當於在oldCap-1的基礎上左側高位再加一個1，所以插入數據hash值在oldCap-1高一位是0還是1將決定
* 數據是否需要遷移，如果是1，則遷移到 j+oldCap位置，如果是0，則保持原位置
*/
//與JDK7不同的是JDK8在擴容時原數據沒有進行鏈表倒置操作，因爲這個在併發編程時會導致
if ((e.hash & oldCap) == 0) {//在原來的散列桶
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
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;
}
}
}
}
}
return newTab;
}
jdk8及其以上版本在多線程下使用雖然沒有死循環問題，但是仍然不是安全的，存在數據丟失以及異常的問題，數據丟失比如在插入時，多個線程同時在一個節點上增加新的節點，多個線程都會將自己新增的節點與某個節點A綁定關係，這樣就會導致其他線程與節點A的關聯關係丟失，類似mysql的update如果不做處理也存在更新丟失問題。異常發生在TreeNode與Node節點強行轉換的地方，比如TreeNode類的moveRootToFront方法，測試代碼可以參考下面：
/**
* JDK8的hashmap雖然沒有jdk7及以前版本存在的死循環問題，但仍然存在丟失數據問題
*/
@Test
public void test(){
Map<String,String> map = new HashMap<>();
Thread[] ts = new Thread[50];
for(int i=0;i<50;i++){
int k = i;
Thread t = new Thread(()->{
for(int j=0;j<500;j++){
map.put(String.format("1001%2d%3d",k,j),"h");
}
});
t.start();
ts[i] = t;
}
for(int i=0;i<50;i++){
try {
ts[i].join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(map.keySet().size());
Map<String,String> map1 = new HashMap<>();
for(int i=0;i<50;i++){
int k = i;
Thread t = new Thread(()->{
for(int j=0;j<500;j++){
map1.put(String.format("1001%2d%3d",k,j),"h");
}
});
t.start();
try {
t.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
for(int i=0;i<50;i++){
try {
ts[i].join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(map1.keySet().size());
}
所以要在併發場景下使用map，可以使用ConcurrentHashMap
