HashMap那些事

HashMap其实是由数组+链表+红黑树组成的，这个特性在JAVA8中已经得以体现。最初并没有红黑树，只是由链表组成，但是，当链表过长时，查询效率会十分低下。所以JAVA8中当链表的长度到达一定的高度时候，便会转换为红黑树，以此来优化性能。
我们可以把HashMap看成是一个数组（它底层的实现也是这样的，只是可能会稍稍复杂），而它是由一个个单链表组成的（数组的每项元素为一个节点的链表）。

　　HashMap 的实例有两个参数影响其性能：初始容量 和加载因子。 
　　容量 ：是哈希表中桶的数量，初始容量只是哈希表在创建时的容量，实际上就是Entry< K,V>[] table的容量 
　　加载因子 ：是哈希表在其容量自动增加之前可以达到多满的一种尺度。它衡量的是一个散列表的空间的使用程度，负载因子越大表示散列表的装填程度越高，反之愈小。对于使用链表法的散列表来说，查找一个元素的平均时间是O(1+a)，因此如果负载因子越大，对空间的利用更充分，然而后果是查找效率的降低；如果负载因子太小，那么散列表的数据将过于稀疏，对空间造成严重浪费。系统默认负载因子为0.75。

HashMap通常会用一个指针数组（假设为table[]）来做分散所有的key，当一个key被加入时，会通过Hash算法通过key算出这个数组的下标i，然后就把这个<key, value>插到table[i]中，如果有两个不同的key被算在了同一个i，那么就叫冲突，又叫碰撞，这样会在table[i]上形成一个链表。只是简单地对数组长度执行取模运算（即仅保留Hash二进制的后i位）
一般当容量大于或等于负载因子，HashMap需要扩容，一般是扩大为原来的两倍，然后进行Rehash操作，然后释放原来的空间。


解决hash冲突的办法
1.开放定址法（线性探测再散列，二次探测再散列，伪随机探测再散列）
2.再哈希法
3.链地址法
4.建立一个公共溢出区 


当ReHash时，数组长度加倍变为2i+1，旧数组第j项链表中的每个节点，要么移动到新数组中第j项，要么移动到新数组中第j+2i项，而它们的唯一区别在于Hash值第i+1位的不同（第i+1位为0则仍为第j项，否则为第j+2i项）
也就是原来下标为3，容量大小为8的HashMap 扩充为容器大小为16的HashMap时，原本下标为3下面的链表要么还在下标为3的下面，要么在3+2*（4）= 8的下标下面。

接下来，我们来看看它的源代码

public V put(K key, V value)
{
    ......
    //算Hash值
    int hash = hash(key.hashCode());
    int i = indexFor(hash, table.length);
    //如果该key已被插入，则替换掉旧的value （链接操作）
    for (Entry<K,V> e = table[i]; e != null; e = e.next) {
        Object k;
        if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
            V oldValue = e.value;
            e.value = value;
            e.recordAccess(this);
            return oldValue;
        }
    }
    modCount++;
    //该key不存在，需要增加一个结点
    addEntry(hash, key, value, i);
    return null;
}


//检查容量是否超标
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);
    //查看当前的size是否超过了我们设定的阈值threshold，如果超过，需要resize
    if (size++ >= threshold)
        resize(2 * table.length);
}


//ReHash 开辟空间，转移数据
void resize(int newCapacity)
{
    Entry[] oldTable = table;
    int oldCapacity = oldTable.length;
    ......
    //创建一个新的Hash Table
    Entry[] newTable = new Entry[newCapacity];
    //将Old Hash Table上的数据迁移到New Hash Table上
    transfer(newTable);
    table = newTable;
    threshold = (int)(newCapacity * loadFactor);
}

//具体的转移过程
void transfer(Entry[] newTable)
{
    Entry[] src = table;
    int newCapacity = newTable.length;
    //下面这段代码的意思是：
    //  从OldTable里摘一个元素出来，然后放到NewTable中
    for (int j = 0; j < src.length; j++) {
        Entry<K,V> e = src[j];
        if (e != null) {
            src[j] = null;
            do {
                Entry<K,V> next = e.next;
                int i = indexFor(e.hash, newCapacity);
                e.next = newTable[i];
                newTable[i] = e;
                e = next;
            } while (e != null);
        }
    }
}

交接我们就来看看ReHash的过程：

拿下图为例

最后再把数据（key5）插入，然后结束。

HashMap并不能直接应用于多线程环境，这是为什么呢？

当线程一扩容完毕准备，移动数据时，切换到线程二。当线程二中的数据插入到一定程度时，切回线程一，而，e和next的位置还是原来数据的位置，但是现在却颠倒了，如下图

可以看见，此时已经形成环，正如源码中红色标注的代码一样

我们看到，java.util.HashMap并不能直接应用于多线程环境。对于多线程环境中应用HashMap，主要有以下几种选择：
1.使用线程安全的java.util.Hashtable作为替代。
2.使用java.util.Collections.synchronizedMap方法，将已有的HashMap对象包装为线程安全的。
3.使用java.util.concurrent.ConcurrentHashMap类作为替代，它具有非常好的性能。

而以上几种方法在实现的具体细节上，都或多或少地用到了互斥锁。互斥锁会造成线程阻塞，降低运行效率，并有可能产生死锁、优先级翻转等一系列问题。

其实还有其他的办法

点击打开链接可以查看

本文参考https://coolshell.cn/articles/9606.html