hashmap在多线程下数据丢失问题

我们都知道hashmap是非线程安全的。什么是非线程安全呢？个人理解，就是在多线程环境下，一个线程对值做变更时，不会立即同步到其他线程，这时候其他线程获取该值的话就是取到旧值，如果在此基础上进行计算的话就会得到错误的结果。

这点应该和java的内存模型有关，java内存分为工作内存和主内存。如图下所示（图为网上所找，侵删）：

java所有的变量都存储在主内存中，工作内存保存的是主内存的副本，线程所有对变量的操作都是在工作内存中完成的，无法直接操作主内存。而线程写变量到工作内存，再由工作内存同步到主内存，这一过程并不是原子的，所以有可能你其中一个线程的对变量做了改变，但是变量的改变还没有同步到主内存，或者说其他线程没有从主内存获取到最新的值到该线程对应的工作内存的话就可能出现其他线程使用到的变量不是最新的。

基于以上两点，我们来看一下为什么多线程环境下hashmap会出现数据丢失的情况，它不是key value对应的吗？为什么key不同 还会出现数据丢失呢。下面我们来看看源码：

    public HashMap(int initialCapacity, float loadFactor) {
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " +
                                               initialCapacity);
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);
        this.loadFactor = loadFactor;
        this.threshold = tableSizeFor(initialCapacity);
    }

这是一段hashmap的构造方法，用来初始化负载因子和阈值。这里有个疑问，如果有小伙伴知道的话麻烦告诉我下，就是阈值的算法应该是tableSize * loadFactor，这里为什么直接赋值tableSize呢？tableSizeFor函数这里就不展开了，大概逻辑就是找到传入参数的最接近的下一个2的幂次方，举例说明就是：传入2返回2，传入3返回4。

接着再看下一段源码：

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; // 1.resize为扩容方法
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null); // 2.数组赋值
        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) 
                            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;
}

final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;
        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)
                newThr = oldThr << 1; // double threshold
        }
        else if (oldThr > 0) // initial capacity was placed in threshold
            newCap = oldThr;
        else {               // zero initial threshold signifies using defaults
            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;
                            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;
    }

看源码，当table为null时，这时候put值将会触发resize扩容操作。而new HashMap时并没有初始化table的操作，只有在resize时table才会真正有值。所以在put第一个值时必定触发resize。resize的操作这里不细讲，主要逻辑就是根据负载因子和阈值判断当前map的size是否超出阈值，如果超出则进行扩容，扩容的方式为new一个新的数组，再将旧数组的值重新计算hash返回到新的数组中 。我们知道hashmap底层的数据结构为 数组 + 链表 + 树，通过算key的hash值找到对应数组的索引，在索引位置赋值，hash冲突时以链表方式存储，在超过一定数量的情况下转为树，这里不再展开。重点就在标记段。
这里有3点我总结一下：

1. put第一个元素时触发resize操作
2. resize是new一个新的数组，再将旧数组一个个放进新数组中（重新算数组索引位置）
3. hash冲突时以链表或者树的方式存储

所以：
1、当两个线程同时put元素时，因为两个都是在自己的工作内存中操作变量，所以可能情况下就是两个线程都认为自己是第一个put然后都触发了resize操作，且都认为oldTab为null，则必然有一个线程的赋值会丢失。
2、当两个线程同时put元素时，若不触发resize（也许在前一步已经put过其他元素），但是两个key的hash对应的数组索引可能冲突，如此两个可能都以为自己是链表的头，或者是在链表的同一个位置，导致覆盖对方线程的赋值

总结一下：如此我们知道hashmap数据丢失时是由于同时resize或者hash冲突导致，所以有没有一种情况我们可以绕过这两种情况，找到一个办法在多线程下hashmap也不丢失数据呢？答案是有的，一个邪魔歪道:

    public static void main(String[] arrs){
        for (int i = 0; i < 1000000; i++) {
            Map<Integer, Integer> map = new HashMap<>(8); // 这里初始大小定义也要注意，如果过小的话，put时元素超过阈值就也会resize了
            map.put(2, 2); // 先赋值 resize 防止多个线程同时resize
            Arrays.stream(new int[]{1, 10}).parallel().forEach(v -> { // 这里 1，10对应的hash不冲突
                map.put(v, v);
            });
            if(!map.toString().equals("{1=1, 2=2, 10=10}")){
                System.out.println(map.size());
                System.out.println(map);
            }
        }
    }

这段代码打印时正常不会有数据丢失的情况。当然小伙伴们可以按照原理再尝试下其他值或多遍历几次。
原则只有两个：

1. 不要多个线程同时触发resize
2. 不要多个线程赋值时hash冲突

当然有细心的小伙伴会发现我判断数据丢失怎么是通过toString方法来比较，不能直接用size吗？这里不能的，因为呀，java运算并不是原子的，这个size也只是个普通的int，在put时++size，按照我们开头讲的内存模型的问题，size自增时可能取到的并不是已经变更过的值，导致赋值写入的时候将错误的值写入，然后同步到主内存的。所以就可能会出现map中值是有3个但是size确为2的情况，所以这种邪魔歪道能不用还是不用，大家看个乐就行。

各位小伙伴，如果发现我哪里写错了，欢迎指正，大家一起进步~，谢谢大家。写的不好，请多担待。