关于HashMap在多线程中不安全引起死锁问题

• 通过看源码，可以得出死锁发生在扩容数组时复制链表的时候，也就是resize的transfer方法上
• JDK1.8之后优化了HashMap，改用尾插法，不会出现环形链了，但会出现覆盖；本文章只讨论JDK1.7之前的

/** 
    * 
    * 往表中添加元素，如果插入元素之后，表长度不够，便会调用resize方法扩容 
    */  
   void addEntry(int hash, K key, V value, int bucketIndex) {  
Entry<K,V> e = table[bucketIndex];  
       table[bucketIndex] = new Entry<K,V>(hash, key, value, e);  
       if (size++ >= threshold)  
           resize(2 * table.length);  
   }  
  
   /** 
    * resize()方法如下，重要的是transfer方法，把旧表中的元素添加到新表中
    */  
   void resize(int newCapacity) {  
       Entry[] oldTable = table;  
       int oldCapacity = oldTable.length;  
       if (oldCapacity == MAXIMUM_CAPACITY) {  
           threshold = Integer.MAX_VALUE;  
           return;  
       }  
  
       Entry[] newTable = new Entry[newCapacity];  
       transfer(newTable);  
       table = newTable;  
       threshold = (int)(newCapacity * loadFactor);  
   }  

/**
     * newTable：是要复制到的新数组，里面的元素是Entry<k, v>链表
     * rehash：是否重新哈希计算
     */
    void transfer(Entry[] newTable, boolean rehash) {
        int newCapacity = newTable.length;
        //table指的是旧HashMap数组Entry[] table
        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);
                }
                //1.计算出e元素在新元素的数组中的位置
                int i = indexFor(e.hash, newCapacity); 
                //2.将e元素的next指向新数组中的当前位置中的元素，如果没有则为null
                e.next = newTable[i];
                //3.将e元素放进新数组中的当前位置
                newTable[i] = e;
                //4.开始判断下一个元素进行复制，此时步骤走到2、3，即完成了头插法，顶替前一个元素在数组的头位置，插在前一个元素的前面。
                e = next;
            } // while
        }
    }

实例证明可能会发生的死锁循环：
声明2个线程A、B、线程A和B都是保存HashMap元素的引用，而非元素的copy，并且是在不重新计算hash的情况，或者新的hash和之前的hash值相同的情况，结构如下，

1. A先开始执行扩容操作，将3放进新的数组里：
   
2. 此时挂起A；B开始扩容，扩容至完成时，B是这样的，为什么顺序倒了，可以看上面的代码注释，采用头插法复制：
   
3. 此时A开始唤醒工作，在transer的while循环插入7时，原本A中7的next节点是null，但是由于B完成了复制，此时7的next节点变为了3，所以A在插入7之后，本该停止的复制操作，由于next节点由null变为3了，又开始了一次复制，此时复制3到新数组的头节点；由于头插法，3强制指向7，所以A线程中最后的新数组会变成3->7->3这个循环：

4. 此时如果查询同一hash的节点5，就会在3->7->3中循环查询，浪费CPU，造成死锁，如果要避免这种情况，需使用ConcurrentHashMap。