HashMap为什么是线程不安全的

首先看一下HashMap的工作原理，回顾以下HashMap的结构：

HashMap的结构就是哈希表，底层是一个数组，这个数组中尽可能地分散所有的key，通过key的hash值得到数组下标，然后把entry插入到该数组，假如有两个不同的key被分到相同发的下标，也就是哈希冲突，那么该数组在该下标下就会形成链表。对链表而言，新加入的节点会从头节点加入。
此实现不是同步的。如果多个线程同时访问一个哈希映射，而其中至少一个线程从结构上修改了该映射，则它必须保持外部同步。（结构上的修改是指添加或删除一个或多个映射关系的任何操作；仅改变与实例已经包含的键关联的值不是结构上的修改。）这一般通过对自然封装该映射的对象进行同步操作来完成。如果不存在这样的对象，则应该使用Collections.synchronizedMap方法来包装该映射。最好在创建时完成这一操作，以防止对映射进行意外的非同步访问，如下图所示：
Map m = Collections.synchronizedMap(new HashMap(…));
1、添加键值对的代码

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);
    }

在hashmap做put操作的时候会调用到以上的方法。现在假如A线程和B线程同时对一个数组位置调用addEntry，两个线程会同时得到现在的头节点，然后A写入新的头节点之后，B也写入新的头节点，那B的写入操作就会覆盖A的写入操作造成A的写入操作丢失。
2、删除键值对的代码

final Entry<K,V> removeEntryForKey(Object key) {
        int hash = (key == null) ? 0 : hash(key.hashCode());
        int i = indexFor(hash, table.length);
        Entry<K,V> prev = table[i];
        Entry<K,V> e = prev;
 
        while (e != null) {
            Entry<K,V> next = e.next;
            Object k;
            if (e.hash == hash &&
                ((k = e.key) == key || (key != null && key.equals(k)))) {
                modCount++;
                size--;
                if (prev == e)
                    table[i] = next;
                else
                    prev.next = next;
                e.recordRemoval(this);
                return e;
            }
            prev = e;
            e = next;
        }
 
        return e;
    }

当多个线程同时操作同一个数组位置的时候，也都会先取得现在状态下该位置存储的头节点，然后各自去进行计算操作，之后再把结果写到该数组位置中去，其实写回的时候可能其他的线程已经就把这个位置给修改过了，就会覆盖其他线程的修改。
3、addEntry中当加入新的键值对后键值对总数量超过门限值的时候会调用一个resize操作，代码如下：

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);
    }

这个操作会新生成一个新的容量的数组，然后对原数组的所有键值对重新进行计算和写入新的数组，之后指向新生成的数组。
当多个线程同时检测到总数量超过门限值的时候就会同时调用resize操作，各自生成新的数组并rehash后赋给该map底层的数组table，结果最终只有最后一个线程生成的新数组被赋给table变量，其他线程的均会丢失。而且当某些线程已经完成赋值而其他线程刚开始的时候，就会用已经被赋值的table作为原始数组，这样也会有问题。
为了减少冲突，我们需要时刻留意当前的size是否太大，检查是否需要扩容，一旦超过设定的threshold，那么就要重新增大数组尺寸，此时所有元素等都需要重新计算应该放置的下标。
扩容、rehash
一般声明HashMap时，使用的都是默认的构造方法：HashMap<K,V>，看了代码会发现，它还有其它的构造方法：HashMap(int initialCapacity,float loadFactor)，其中参数initialCapacity为初始容量，loadFactor为加载因子，扩容就是在put加入元素的个数超过initialCapacity*loadFactor的时候就会将内部Entry数组大小扩大至原来的2倍，然后将数组元素按照新的数组大小重新计算索引，放在新的数组中，同时修改每个节点的链表关系（主要是next和节点在链表中的位置）。

先上一组代码：

    public static void main(String[] args) {
       Map map = new HashMap();
         for(int i = 0; i < 100; i++) {
            map.put("键" + i,"值" + i);
            map.remove("键" + i);
            System.out.println(i + "\tsize:" + map.size());
        }
    }

结果如下：

我添加一个key，然后再移除key，size大小为0，逻辑上是没有任何问题的。结果证明也是没有问题的。单线程执行代码一般都是没有任何问题大的，是按照逻辑来的。即使指令重排，对结果影响基本为0的。
现在我们上一组多线程代码：

  public static void main(String[] args) {

    Map<String, String> map = new HashMap<String, String>();
    for (int i = 0; i < 100; i++) {
      MyThread myThread = new MyThread(map, "线程名字：" + i);
      myThread.start();
    }
  }

  static class MyThread extends Thread {
    public Map map;
    public String name;

    public MyThread(Map map, String name) {
      this.map = map;
      this.name = name;
    }
    public void run() {
      double i = Math.random() * 100000;
      map.put("键" + i, "值" + i);
      map.remove("键" + i);
      System.out.println(name + "当前时间：" + i + "   size = " + map.size());
    }
  }

结果如图：

上图可以看出来HashMap是线程不安全的。
size()这个方法的源码：

public int size() {
        return size;
}

很简单的逻辑，然后看看size这个变量说明：

    /**
     * The number of key-value mappings contained in this map.
     */
    transient int size;

大意就是说包含的键值对数量，还是一个不可序列化对象。
首先这个size没有用volatile关键字修饰，代表这不是一个内存可见的变量。了解过多线程应该都知道，线程操作数据的时候一般是从主内存拷贝一个变量副本进行操作。
示意图：

线程中的变量都是从主内存拷贝过去，操作完成后再把size的值写回到主内存size的。
接下来分析以下源码put(K key,V value)的实现过程。

    public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }

好像没有什么操作，就调用了一个putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict)方法，继续往下看，putVal()方法也没有用synchronized修饰，代表这个方法里面的任意的位置时间片耗尽（可以类比休眠状态，休眠是主动进入阻塞，休眠结束进入就绪状态，时间片耗尽是直接进入就绪状态）。

    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
         //这里是核心，大概就是各种判断，然后赋值的问题，感兴趣的可以自己去了解一下。
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

resize()方法就是扩容器的策略，问题出在++size上面的，如果键是以前不存在的，那么必然会执行++size这段逻辑。假设现在有两个线程，每个线程都在执行put方法。

size的大致变化过程就是这样的，理论结果应该是size=3的，而实际执行的结果是size=2，remove()方法的原理也差不多的。这肯定和我们的预期是有差距的，如果去银行存钱，你存了两次100元，银行只给你账号增加了100元。但是如果一笔钱你能花两次，你估计会非常开心吧。
这只是一个int型的变量size，假设两个线程分别调用put(1,“111”)和put(1,“222”)，那么get(1)取到的究竟是哪个值呢？比如线程A先调用get(1)还没有执行完成的时候，A线程时间片用尽进入就绪状态，然后B线程调用remove(1)，A继续回来执行的get(1)的剩余逻辑。
总结：1、多个线程某一时刻同时操作HashMap并执行put，hash值相同，需解决冲突。2、put()方法不是同步的。3、addEntry()方法不是同步的。4、resize()扩容方法不是同步的。