为什么说HashMap线程不安全问题？

HashMap有哪些线程安全问题？

1. 所有的jdk都存在的线程不安全全问题：数据覆盖
2. jdk1.7：当出现哈希冲突，jdk1.7采用的是头插法，存在安全问题，数据丢失，链表环化到程序卡死。

线程问题一分析：数据覆盖导致插入数据丢失

当在同一时刻多个线程同时操作共享数据，就存在着线程安全的问题。HashMap的共享数据是哈希表table，如果线程A在准备完数据后，还没来得及将数据插入table中，此时线程A被挂起，线程B获取CPU执行时间，并完成数据的插入，table被更新了，但是线程A并不知道table“脏”了，继续添加数据把线程B添加的数据给覆盖掉。

假如线程A将要添加的数据节点3的哈希值与线程B将要添加的节点数据4的哈希值相同（也就是说他们添加的位置在同一条链表）。


阶段1：线程A找到插入位置为节点2之后，线程A被挂起，线程B获取CPU执行时间。
阶段2：线程B完成插入操作，将数据节点4链接在节点2之后。
阶段3：线程A获得CPU执行时间。但是线程A不知道节点2指向不为空，将节点2的指向指向3节点，导致节点4脱离了链表，不在table表中从而导致数据丢失。

//jdk1.8,尾插法
//onlyIfAbsent：如果为true时，添加的值已存在时，则不添加进去
//evict：是否HashMap创建期间
//返回值，如果添加的值不存在，则返回null，如果存在，则返回老值
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
  //数组的类型为节点类型的数据Node
     Node<K,V>[] tab; 
  //节点指针，用来定位目标节点插入的位置
 	 Node<K,V> p; 
 	 int n, i;
  //数组为空时，初始化数组的长度为 resize()
    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;
      //判断p是否实现了TreeNode
        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);
                  //判断节点数是否超过成为数的阈值：TREEIFY_THRESHOLD=8
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                      //将链表转换为红黑树的结构，这里会先对数组的长度进行判断，如果小于64，则直接进行扩容
                      	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;
          //在LinkedHashMap会调用该方法，
            afterNodeAccess(e);
            return oldValue;
        }
    }
  //修改数据次数+1
    ++modCount;
  //数组size实际长度+1，判断实际长度是否大于阈值threshold，大于则进行调整容量
    if (++size > threshold)
        resize();
  //在LinkedHashMap会调用该方法，
    afterNodeInsertion(evict);
    return null;
}

线程安全问题二分析：链表环化，数据丢失。

链表环化是发生在链表扩容时进行hash的重新布局阶段。当线程A进行扩容时，刚新建出一个新数组时，被挂起。线程B完成扩容后，由于jdk1.7采用的是头插的方式，导致链表的下一次连接与上一次连接的形式是相反的。这时回到线程A的时候数据已经发生了变化，但是当前指向的节点不再是第一个节点，而是最后一个节点，下一个节点指向的是倒数第二个节点，导致新的表只有两个节点，并形成环状。

假设有一个hashmap如图所示，当put()一个节点后，由于容量不足需要先进行扩容。扩容的过程如下，最rehash后的结果是链表的翻转。

假如线程A在扩容时，刚好定位到原先的链表，刚要进行rehash是，被挂起。指针的指向如阶段一。线程B获得执行权，并完成了扩容，链表反转，如阶段二，但是此时e指针依旧是节点2，next节点是指向3节点，但是next指针在e指针之前，这种就导致节点2跟节点3会被遍历两次，节点1没有被遍历到。最终导致节点2指向节点3，节点3指向节点2.从而形成环状链表。节点1数据被丢失。最终出现阶段三这种情况。

void resize(int newCapacity) {
    //获取哈希表
    Entry[] oldTable = table;
    //获取哈希表的实际长度
    int oldCapacity = oldTable.length;
    //容量最大值判断
    if (oldCapacity == MAXIMUM_CAPACITY) {
        threshold = Integer.MAX_VALUE;
        return;
    }
//新建数组，直接2倍扩容
    Entry[] newTable = new Entry[newCapacity];
    //rehash：重新将原来的表节点重新布局到新数组中
    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;
        }
    }
}