hashmap原理总结

Hashmap详解

       hashmap是日常非常常用的数据结构，也是互联网公司面试常常出现的面试题考点，下面对hashmap做一个简单的总结。

一、      前言

Hashmap是java.util.Map接口下的一个类，此接口主要有linkedHashMap、TreeMap、HashTable类。对于LinkedHashMap，，主要作用就是保存了插入时的顺序，当使用iteratorb遍历的时候，遍历的结果就是插入时的结果。TreeMap主要用作给Key排序，底层使用红黑树数据结构实现，想要实现排序需要key实现Comparable接口或者在TreeMap的构造函数中传入比较器Comparator。HashTable是历史遗留类，现在使用较少。

重点是HashMap.首先明确HashMap的几个参数：

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;// 默认初始容量16

static final float DEFAULT_LOAD_FACTOR = 0.75f;// 加载因子

transient int size;//HashMap中实际存放的键值对的个数

int threshold;// 扩容阈值

       这里的thread就是HashMap中实际最多放几个键值对，当超过threshold之后就会发生扩容，扩大为之前的两倍。Threshold=length×loadfactor，其中length和loadfactor可以自己在构造函数中定义。一般扩容会影响性能，所以我们要是预先知道在hashmap中存放的元素数量，最好是指定初始容量，以免频繁发生扩容。对于加载因子而言，一般不需要改动，因为改的太大，可能会因为频繁的hash碰撞引起性能损失，改的太小 又可能浪费存储空间。

HashMap底层使用的数据结构因为JDK版本而有所不同。对于1.7版本，是Entry对象形成的数组static class Entry<K,V> implements Map.Entry<K,V>。对于1.8版本，是static class Node<K,V>implements Map.Entry<K,V>形成的数组，二者都实现了Map.Entry<K,V>接口。1.8新加了红黑树的数据结构，具体应用之后再说。

HashMap是使用hash表存储数据的，使用hash就不可避免的出现hash冲突。Hash冲突主要受到两方面的影响：一是桶的大小，如果桶的数量非常大，那么两个键装在同一个桶中的概率就比较低。二是hash函数的好坏，如果hash函数不够好，那么最极端的是每次hash之后总是放在同一个桶中，结果是很差的性能。使用hash解决的问题主要是如何实将键很好的实现均匀散列，如何适当的扩容。下面详细总结HashMap如何hash以及存放数据和扩容。

二、      如何hash到数组

一般我们通常使用的hash就是取模运算，比如直接使用key.hashcode%length.但是取模预算消耗比较大，hashmap中使用了一种比较巧妙的方法。取余数需要注意一点就是hashcode的每一位都参与到了bucket的映射。比如Hashcode=0111 1111 1111 0001，任何一位改变，都会引起最终分配到哪一个桶。Hashmap使用的方法也是需要考虑到这一点。

比如在1.8中hash函数源码是

static final int hash(Object key) {        int h;        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);    }

我们发现hashcode的低16位和高16位都参与到运算，只要有一个bit变化，都影响到了最后分到哪一个bucket。

对于jdk1.7中hash函数：

final int hash(Object k) {        int h = hashSeed;// 默认是0        if (0 != h &&k instanceof String) {            returnsun.misc.Hashing.stringHash32((String) k);        }        h ^= k.hashCode();        h ^= (h >>>20) ^ (h >>> 12);        return h ^ (h>>> 7) ^ (h >>> 4);

}也是同样的目的。具体原理参考http://www.iteye.com/topic/709945。

这就是为什么不直接使用hashcode&（length-1）,因为直接这样做，hashcode的高位就算有一个bit变化，也不影响分桶位置。hash&（length-1）中需要注意一点就是length （hashmap内数组容量）的大小必须是2的幂。因为length是2^n，则保证了length是偶数，length-1就是奇数，这样hash&（length-1）分桶时所有的桶都能被映射到。如果length是奇数，length-1是偶数，length-1最后的bit就是0.那么hash&（length-1）的结果的最后bit总是0，相当于一半的桶被浪费，永远不会装key.

 

小结：为了不使用取模运算，hashmap使用了如下替代方法：首先对key的hashcode进行hash,确保所有的bit参与运算。再对这个结果hash&（length-1），目的是找到bucket。之所以不直接使用hashcode&（length-1）是因为hashcode高位即使不同，也总是映射到相同的桶中，增加了hash碰撞的概率。

 

三、      如何put操作

知道了上边的知识，put操作就比价好理解了。

Jdk1.7源码

     

  // 将“key-value”添加到HashMap中    public V put(K key, V value) {        // 若“key为null”，则将该键值对添加到table[0]中。        if (key == null)            return putForNullKey(value);        // 若“key不为null”，则重新计算该key的哈希值，然后将其添加到该哈希值对应的链表中。        int hash = hash(key.hashCode());        int i = indexFor(hash, table.length);        for (Entry<K, V> e = table[i];e != null; e = e.next) {            Object k;            // 若“该key”对应的键值对已经存在，则用新的value取代旧的value。然后退出！            if (e.hash == hash &&((k = e.key) == key || key.equals(k))) {                V oldValue = e.value;                e.value = value;                e.recordAccess(this);                return oldValue;            }        }// 若“该key”对应的键值对不存在，则将“key-value”添加到table中        modCount++;        // 将key-value添加到table[i]处        addEntry(hash, key, value, i);        return null;    }

 

Jdk1.8源码如下

1 public V put(K key, V value) { 2     //对key的hashCode()做hash 3    return putVal(hash(key), key, value, false, true); 4 } 5 6final V putVal(int hash, K key, V value, boolean onlyIfAbsent, 7                boolean evict) { 8    Node<K,V>[] tab; Node<K,V> p; int n, i; 9     //步骤①：tab为空则创建10    if ((tab = table) == null || (n = tab.length) == 0)11        n = (tab = resize()).length;12    // 步骤②：计算index，并对null做处理13    if ((p = tab[i = (n - 1) & hash]) == null)14        tab[i] = newNode(hash, key, value, null);15    else {16        Node<K,V> e; K k;17        // 步骤③：节点key存在，直接覆盖value18        if (p.hash == hash &&19             ((k = p.key) == key || (key !=null && key.equals(k))))20             e = p;21        // 步骤④：判断该链为红黑树22        else if (p instanceof TreeNode)23             e =((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);24        // 步骤⑤：该链为链表25        else {26             for (int binCount = 0; ;++binCount) {27                 if ((e = p.next) == null) {28                     p.next = newNode(hash,key,value,null);                        //链表长度大于8转换为红黑树进行处理29                     if (binCount >= TREEIFY_THRESHOLD -1) // -1 for 1st 30                         treeifyBin(tab, hash);31                     break;32                 }                    // key已经存在直接覆盖value33                 if (e.hash == hash &&34                    ((k = e.key) == key|| (key != null && key.equals(k))))                                         break;36                 p = e;37             }38        }39        40        if (e != null) { // existing mapping for key41             V oldValue = e.value;42             if (!onlyIfAbsent || oldValue ==null)43                 e.value = value;44             afterNodeAccess(e);45             return oldValue;46        }47    } 48    ++modCount;49    // 步骤⑥：超过最大容量 就扩容50    if (++size > threshold)51        resize();52    afterNodeInsertion(evict);53    return null;54 }

 

这里注意的1.7与1.8引入红黑树的区别。1.7中，当出现频繁的碰撞，总是形成链表，这样在最坏的情况下，遍历链表时间复杂度是O(n).但是1.8中在链表超过8以后就将链表转换为红黑树，在极端情况下，访问节点的时间复杂度是O(logn)。

四、      如何扩容

前面已经讲到：影响HashMap除了hash函数的好坏之外，还有容量。虽然hash函数足够好，但是容量太小还是频繁碰撞。下面总结下扩容机制。

1.8引入了红黑树，源码比较复杂，但是本质上和1.7差别不大。所以以下使用1.7的源码来说明

1 voidresize(int newCapacity) {   //传入新的容量 2    Entry[] oldTable = table;    //引用扩容前的Entry数组 3    int oldCapacity = oldTable.length;         4     if(oldCapacity == MAXIMUM_CAPACITY) {  //扩容前的数组大小如果已经达到最大(2^30)了 5        threshold = Integer.MAX_VALUE; //修改阈值为int的最大值(2^31-1)，这样以后就不会扩容了 6        return; 7     } 8  9    Entry[] newTable = new Entry[newCapacity];  //初始化一个新的Entry数组10     transfer(newTable);                         //！！将数据转移到新的Entry数组里11     table = newTable;                           //HashMap的table属性引用新的Entry数组12     threshold = (int)(newCapacity *loadFactor);//修改阈值13 }

 

实际就是新建一个大数组，然后将旧数组的键依次重新hash到新数组上。也即是transfer方法。

1 voidtransfer(Entry[] newTable) { 2    Entry[] src = table;                  //src引用了旧的Entry数组 3    int newCapacity = newTable.length; 4    for (int j = 0; j < src.length; j++) { //遍历旧的Entry数组 5        Entry<K,V> e = src[j];            //取得旧Entry数组的每个元素 6        if (e != null) { 7            src[j] = null;//释放旧Entry数组的对象引用（for循环后，旧的Entry数组不再引用任何对象） 8            do { 9                 Entry<K,V> next =e.next;10                 int i = indexFor(e.hash, newCapacity); //！！重新计算每个元素在数组中的位置11                 e.next = newTable[i]; //标记[1]12                 newTable[i] = e;      //将元素放在数组上13                 e = next;             //访问下一个Entry链上的元素14             } while (e != null);15         }16     }17 }

下面举个例子说明下扩容过程。假设了我们的hash算法就是简单的用key mod 一下表的大小（也就是数组的长度）。其中的哈希桶数组table的size=2， 所以key = 3、7、5，put顺序依次为 5、7、3。在mod 2以后都冲突在table[1]这里了。这里假设负载因子 loadFactor=1，即当键值对的实际大小size 大于 table的实际大小时进行扩容。接下来的三个步骤是哈希桶数组 resize成4，然后所有的Node重新rehash的过程。

 

DK1.8做了优化。经过观测可以发现，我们使用的是2次幂的扩展(指长度扩为原来2倍)，所以，元素的位置要么是在原位置，要么是在原位置再移动2次幂的位置。看下图可以明白这句话的意思，n为table的长度，图（a）表示扩容前的key1和key2两种key确定索引位置的示例，图（b）表示扩容后key1和key2两种key确定索引位置的示例，其中hash1是key1对应的哈希与高位运算结果。

元素在重新计算hash之后，因为n变为2倍，那么n-1的mask范围在高位多1bit(红色)，因此新的index就会发生这样的变化：

因此，我们在扩充HashMap的时候，不需要像JDK1.7的实现那样重新计算hash，只需要看看原来的hash值新增的那个bit是1还是0就好了，是0的话索引没变，是1的话索引变成“原索引+oldCap”，可以看看下图为16扩充为32的resize示意图：

这个设计确实非常的巧妙，既省去了重新计算hash值的时间，而且同时，由于新增的1bit是0还是1可以认为是随机的，因此resize的过程，均匀的把之前的冲突的节点分散到新的bucket了。这一块就是JDK1.8新增的优化点。有一点注意区别，JDK1.7中rehash的时候，旧链表迁移新链表的时候，如果在新表的数组索引位置相同，则链表元素会倒置，但是从上图可以看出，JDK1.8不会倒置。

五、      线程安全性

第一，如果多个线程同时使用put方法添加元素

假设正好存在两个put的key发生了碰撞(hash值一样)，那么根据HashMap的实现，这两个key会添加到数组的同一个位置，这样最终就会发生其中一个线程的put的数据被覆盖。

 

第二，如果多个线程同时检测到元素个数超过数组大小*loadFactor

这样会发生多个线程同时对hash数组进行扩容，都在重新计算元素位置以及复制数据，但是最终只有一个线程扩容后的数组会赋给table，也就是说其他线程的都会丢失，并且各自线程put的数据也丢失。

 

第三，会引起死循环的错误。

       在多线程使用场景中，应该尽量避免使用线程不安全的HashMap，而使用线程安全的ConcurrentHashMap。那么为什么说HashMap是线程不安全的，下面举例子说明在并发的多线程使用场景中使用HashMap可能造成死循环。代码例子如下(便于理解，仍然使用JDK1.7的环境)：

public class HashMapInfiniteLoop {     private static HashMap<Integer,String> map = newHashMap<Integer,String>(2，0.75f);    public static void main(String[] args) {        map.put(5， "C");         new Thread("Thread1") {            public void run() {                 map.put(7, "B");                 System.out.println(map);            };        }.start();        new Thread("Thread2") {            public void run() {                 map.put(3, "A);                 System.out.println(map);            };        }.start();           } }

其中，map初始化为一个长度为2的数组，loadFactor=0.75，threshold=2*0.75=1，也就是说当put第二个key的时候，map就需要进行resize。

通过设置断点让线程1和线程2同时debug到transfer方法(3.3小节代码块)的首行。注意此时两个线程已经成功添加数据。放开thread1的断点至transfer方法的“Entry next = e.next;” 这一行；然后放开线程2的的断点，让线程2进行resize。结果如下图。

 

注意，Thread1的 e 指向了key(3)，而next指向了key(7)，其在线程二rehash后，指向了线程二重组后的链表。

线程一被调度回来执行，先是执行 newTalbe[i] = e， 然后是e = next，导致了e指向了key(7)，而下一次循环的next = e.next导致了next指向了key(3)。

e.next = newTable[i] 导致 key(3).next 指向了 key(7)。注意：此时的key(7).next 已经指向了key(3)， 环形链表就这样出现了。

于是，当我们用线程一调用map.get(11)时，就出现了——Infinite Loop。

 

参考：

Java 8系列之重新认识HashMap https://zhuanlan.zhihu.com/p/21673805

主题：HashMap hash方法分析http://www.iteye.com/topic/709945