HashMap不得不说的故事

概要

Map属于Java常用的数据结构，其中HashMap和ConcurrentHashMap是使用非常高频的两个类，本文主要对HashMap一些实现思路及高频问题进行分析。

HashMap

HashMap根据键的HashCode值存储数据，大多数情况下可以通过hash直接定位到它的值，因而具有很快的访问速度，但遍历顺序却是不确定的。HashMap最多只允许一条记录的键为null，允许多个值为null。HashMap不是线程安全的类，如果在多线程环境下进行写入操作，可能会导致内部链表变成成环形链表，形成死循环（JDK1.7实现）。

Java7 实现

HashMap1.7的结构实现大体像上图,HashMap里面是一个数组，其中数组里的每个元素是一个单向链表，上图中每个蓝色的实体是内部类Entry的实例，Entry包含四个属性:key,value,hash和用于单向链表的next。

其中HashMap的关键几个初始化参数是

	//数组的默认容量,默认16.可以扩容，按照当前大小的2倍来扩容，始终保持2^n
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
    //负载银子,默认为0.75
    static final float DEFAULT_LOAD_FACTOR = 0.75f;
	//扩容后阈值，等于capacity*loadFactor
	int threshold;

Java8 实现

Java8对HashMap的源码进行了一些修改，相比之前，最大的不同就是利用了红黑树，在原有数组+链表的基础上，变成了数组+链表+红黑树。

为什么引入1.8里引入了红黑树
在1.8之前，Has和Map的查找是通过hash值快速定位倒数组的具体下表，但是在hash碰撞严重的数组里，需要顺着链表一个个比较下去，才能获取到最终想要的，时间复杂度取决于链表的长度，为O(n).
为了降低这一部分开销，在java1.8中，当链表的元素超过了8个以后，并且table容量大于64的时候，会将链表转换为红黑树，这样就使得在这些位置查找的时候，时间复杂度降低为了O(logN).

 public V put(K key, V value) {
 		//hash(key)
     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;
        //table为空创建
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
       // 算出插入的数组索引i
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; K k;
            // key已存在，直接覆盖
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
             // key不存在，判断是否为红黑树
            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) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    // key 已经存在直接覆盖value
                    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;
    }

下面我们用一张流程图来描述一下在插入的时候发生了什么

Hashmap为什么线程不安全

上面我们介绍了HashMap的插入，对于1.7和1.8的插入实现是不同的，但是不管是哪个版本，HashMap都是线程不安全的。
我们先以1.7为例：
HashMap在多个线程同时执行resize()方法的时候，可能会导致某一个hash槽里的数组形成循环链表，变成死循环。简单点来说，对于某一个槽里的元素 1=>2，在线程A执行扩容时到 2=>1时让出cpu，线程B开始执行，导致该数组变成1=>2,最终变成死循环 1=>2=>1。

	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, initHashSeedAsNeeded(newCapacity));
        table = newTable;
        threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
    }

    /**
     * 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) {
                //此处是关键，t1执行
                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;
            }
        }
    }

我们通过一组数据模拟程序执行的过程：
假设map默认大小为2，已有元素k5，线程t1添加元素k3， 线程t2添加元素k7，t1和t2同时操作添加，
线程t1执行到Entry<K,V> next = e.next;时，让出了cpu，那么此时 t1 中的 e 指向了 k3，而 next 指向了 k7；之后线程 t2 重新 rehash 之后链表的顺序被反转，链表的位置变成了 k5 => k7 =>k3.
当t1重新取得cpu使用权的时候，开始执行后面代码， newTable[i] = e; ，这个时候e的值是k3，相当于把k7的下一个值设置成了k3.在t1执行完成之后，
链表变为 ： k5 => k7 =>k3 =>k7… 这种循环引用，最终导致死循环，cpu100%