1.HashMap实现原理
2.hashmap底层实现原理
3.HashMap为什么不安全？

HashMap实现原理

        HashMap在实际开发中用到的频率非常高，面试中也是热点。所以决定写一篇文章进行分析，希望对想看源码的人起到一些帮助，看之前需要对链表比较熟悉。

        以下都是我自己的理解，欢迎讨论，写的不好轻喷。

        HashMap中的数据结构为散列表，又名哈希表。在这里我会对散列表进行一个简单的介绍，在此之前我们需要先回顾一下 数组、链表的优缺点。

        数组和链表的优缺点取决于他们各自在内存中存储的模式，也就是直接使用顺序存储或链式存储导致的。无论是数组还是链表，都有明显的缺点。而在实际业务中，我们想要的往往是寻址、删除、插入性能都很好的数据结构，散列表就是这样一种结构，它巧妙的结合了数组与链表的优点，并将其缺点弱化（并不是完全消除）

        散列表的做法是将key映射到数组的某个下标，存取的时候通过key获取到下标（index）然后通过下标直接存取。速度极快，而将key映射到下标需要使用散列函数，又名哈希函数。说到哈希函数可能有人已经想到了，如何将key映射到数组的下标。

        图中计算下标使用到了以下两个函数：

        值得注意的是，下标并不是通过hash函数直接得到的，计算下标还要对hash值做index()处理。

        Ps：在散列表中，数组的格子叫做桶，下标叫做桶号，桶可以包含一个key-value对，为了方便理解，后文不会使用这两个名词。

        以下是哈希碰撞相关的说明：

        以下是下标冲突相关的说明：

        很多人认为哈希值的碰撞和下标冲突是同一个东西，其实不是的，它们的正确关系是这样的，hashCode发生碰撞，则下标一定冲突；而下标冲突，hashCode并不一定碰撞

        上文提到，在jdk1.8以前HashMap的实现是散列表 = 数组 + 链表，但是到目前为止我们还没有看到链表起到的作用。事实上，HashMap引入链表的用意就是解决下标冲突。

        下图是引入链表后的散列表：

        如上图所示，左边的竖条，是一个大小为的数组，其中存储的是链表的头结点，我们知道，拥有链表的头结点即可访问整个链表，所以认为这个数组中的每个下标都存储着一个链表。其具体做法是，如果发现下标冲突，则后插入的节点以链表的形式追加到前一个节点的后面。

        这种使用链表解决冲突的方法叫做：拉链法（又叫链地址法）。HashMap使用的就是拉链法，拉链法是冲突发生以后的解决方案。

        Q：有了拉链法，就不用担心发生冲突吗？

        A：并不是！由于冲突的节点会不停的在链表上追加，大量的冲突会导致单个链表过长，使查询性能降低。所以一个好的散列表的实现应该从源头上减少冲突发生的可能性，冲突发生的概率和哈希函数返回值的均匀程度有直接关系，得到的哈希值越均匀，冲突发生的可能性越小。为了使哈希值更均匀，HashMap内部单独实现了hash()方法。

        以上是散列表的存储结构，但是在被运用到HashMap中时还有其他需要注意的地方，这里会详细说明。

        现在我们清楚了散列表的存储结构，细心的人应该已经发现了一个问题：Java中数组的长度是固定的，无论哈希函数是否均匀，随着插入到散列表中数据的增多，在数组长度不变的情况下，链表的长度会不断增加。这会导致链表查询性能不佳的缺点出现在散列表上，从而使散列表失去原本的意义。为了解决这个问题，HashMap引入了扩容与负载因子。

        以下是和扩容相关的一些概念和解释：

        Ps：扩容要重新计算下标，扩容要重新计算下标，扩容要重新计算下标，因为下标的计算和数组长度有关，长度改变，下标也应当重新计算。

        在1.8及其以上的jdk版本中，HashMap又引入了红黑树。

        红黑树的引入被用于替换链表，上文说到，如果冲突过多，会导致链表过长，降低查询性能，均匀的hash函数能有效的缓解冲突过多，但是并不能完全避免。所以HashMap加入了另一种解决方案，在往链表后追加节点时，如果发现链表长度达到8，就会将链表转为红黑树，以此提升查询的性能。

hashmap底层实现原理

       hashmap底层实现原理是SortedMap接口能够把它保存的记录根据键排序，默认是按键值的升序排序，也可以指定排序的比较器，当用Iterator遍历TreeMap时，得到的记录是排过序的。

       å¦‚果使用排序的映射，建议使用TreeMap。在使用TreeMap时，key必须实现Comparable接口或者在构造TreeMap传入自定义的Comparator，否则会在运行时抛出java.lang.ClassCastException类型的异常。

       Hashtable是遗留类，很多映射的常用功能与HashMap类似，不同的是它承自Dictionary类，并且是线程安全的，任一时间只有一个线程能写Hashtable

       ä»Žç»“构实现来讲，HashMap是：数组+链表+红黑树（JDK1.8增加了红黑树部分）实现的。

扩展资料

       ä»Žæºç å¯çŸ¥ï¼ŒHashMap类中有一个非常重要的字段，就是 Node[] table，即哈希桶数组。Node是HashMap的一个内部类，实现了Map.Entry接口，本质是就是一个映射(键值对)，除了K，V，还包含hash和next。

       HashMap就是使用哈希表来存储的。哈希表为解决冲突，采用链地址法来解决问题，链地址法，简单来说，就是数组加链表的结合。在每个数组元素上都一个链表结构，当数据被Hash后，得到数组下标，把数据放在对应下标元素的链表上。

       å¦‚果哈希桶数组很大，即使较差的Hash算法也会比较分散，如果哈希桶数组数组很小，即使好的Hash算法也会出现较多碰撞，所以就需要在空间成本和时间成本之间权衡，其实就是在根据实际情况确定哈希桶数组的大小，并在此基础上设计好的hash算法减少Hash碰撞。

HashMap为什么不安全？

       æˆ‘们都知道HashMap是线程不安全的，在多线程环境中不建议使用，但是其线程不安全主要体现在什么地方呢，本文将对该问题进行解密。

       1.jdk1.7中的HashMap

       åœ¨jdk1.8中对HashMap做了很多优化，这里先分析在jdk1.7中的问题，相信大家都知道在jdk1.7多线程环境下HashMap容易出现死循环，这里我们先用代码来模拟出现死循环的情况：

       public class HashMapTest {     public static void main(String[] args) {         HashMapThread thread0 = new HashMapThread();        HashMapThread thread1 = new HashMapThread();        HashMapThread thread2 = new HashMapThread();        HashMapThread thread3 = new HashMapThread();        HashMapThread thread4 = new HashMapThread();        thread0.start();        thread1.start();        thread2.start();        thread3.start();        thread4.start();    }}class HashMapThread extends Thread {     private static AtomicInteger ai = new AtomicInteger();    private static Map map = new HashMap<>();    @Override    public void run() {         while (ai.get() < ) {             map.put(ai.get(),采购比价 源码 ai.get());            ai.incrementAndGet();        }    }}

       ä¸Šè¿°ä»£ç æ¯”较简单，就是开多个线程不断进行put操作，并且HashMap与AtomicInteger都是全局共享的。

       åœ¨å¤šè¿è¡Œå‡ æ¬¡è¯¥ä»£ç åŽï¼Œå‡ºçŽ°å¦‚下死循环情形：

       å…¶ä¸­æœ‰å‡ æ¬¡è¿˜ä¼šå‡ºçŽ°æ•°ç»„越界的情况：

       è¿™é‡Œæˆ‘们着重分析为什么会出现死循环的情况，通过jps和jstack命名查看死循环情况，结果如下：

       ä»Žå †æ ˆä¿¡æ¯ä¸­å¯ä»¥çœ‹åˆ°å‡ºçŽ°æ­»å¾ªçŽ¯çš„位置，通过该信息可明确知道死循环发生在HashMap的扩容函数中，根源在transfer函数中，jdk1.7中HashMap的transfer函数如下：

       void transfer(Entry[] newTable, boolean rehash) {         int newCapacity = newTable.length;        for (Entry e : table) {             while(null != e) {                 Entry 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;            }        }    }

       æ€»ç»“下该函数的主要作用：

       åœ¨å¯¹table进行扩容到newTable后，需要将原来数据转移到newTable中，注意-行代码，这里可以看出在转移元素的过程中，使用的是头插法，也就是链表的顺序会翻转，这里也是形成死循环的关键点。

       ä¸‹é¢è¿›è¡Œè¯¦ç»†åˆ†æžã€‚

       1.1 扩容造成死循环分析过程

       å‰ææ¡ä»¶ï¼Œè¿™é‡Œå‡è®¾ï¼š

       hash算法为简单的用key mod链表的大小。

       æœ€å¼€å§‹hash表size=2，key=3,7,5，则都在table[1]中。

       ç„¶åŽè¿›è¡Œresize，使size变成4。

       æœªresize前的数据结构如下：

       è¯·ç‚¹å‡»è¾“入图片描述

       å¦‚果在单线程环境下，最后的结果如下：

       è¯·ç‚¹å‡»è¾“入图片描述

       è¿™é‡Œçš„转移过程，不再进行详述，只要理解transfer函数在做什么，其转移过程以及如何对链表进行反转应该不难。

       ç„¶åŽåœ¨å¤šçº¿ç¨‹çŽ¯å¢ƒä¸‹ï¼Œå‡è®¾æœ‰ä¸¤ä¸ªçº¿ç¨‹A和B都在进行put操作。线程A在执行到transfer函数中第行代码处挂起，因为该函数在这里分析的地位非常重要，因此再次贴出来。

       è¯·ç‚¹å‡»è¾“入图片描述

       æ­¤æ—¶çº¿ç¨‹A中运行结果如下：

       è¯·ç‚¹å‡»è¾“入图片描述

       çº¿ç¨‹A挂起后，此时线程B正常执行，并完成resize操作，结果如下：

       è¯·ç‚¹å‡»è¾“入图片描述

       è¿™é‡Œéœ€è¦ç‰¹åˆ«æ³¨æ„çš„点：由于线程B已经执行完毕，根据Java内存模型，现在newTable和table中的Entry都是主存中最新值：7.next=3，3.next=null。

       æ­¤æ—¶åˆ‡æ¢åˆ°çº¿ç¨‹A上，在线程A挂起时内存中值如下：e=3，next=7，newTable[3]=null，代码执行过程如下：

newTable[3]=e ----> newTable[3]=3e=next ----> e=7

       æ­¤æ—¶ç»“果如下：

       è¯·ç‚¹å‡»è¾“入图片描述

       ç»§ç»­å¾ªçŽ¯ï¼š

e=7next=e.next ----> next=3【从主存中取值】e.next=newTable[3] ----> e.next=3【从主存中取值】newTable[3]=e ----> newTable[3]=7e=next ----> e=3

       ç»“果如下：

       è¯·ç‚¹å‡»è¾“入图片描述

       å†æ¬¡è¿›è¡Œå¾ªçŽ¯ï¼š

e=3next=e.next ----> next=nulle.next=newTable[3] ----> e.next=7 å³ï¼š3.next=7newTable[3]=e ----> newTable[3]=3e=next ----> e=null

       æ³¨æ„æ­¤æ¬¡å¾ªçŽ¯ï¼še.next=7，而在上次循环中7.next=3，出现环形链表，并且此时e=null循环结束。

       ç»“果如下：

       è¯·ç‚¹å‡»è¾“入图片描述

       åœ¨åŽç»­æ“ä½œä¸­åªè¦æ¶‰åŠè½®è¯¢hashmap的数据结构，就会在这里发生死循环，造成悲剧。

       1.2 扩容造成数据丢失分析过程

       éµç…§ä¸Šè¿°åˆ†æžè¿‡ç¨‹ï¼Œåˆå§‹æ—¶ï¼š

       è¯·ç‚¹å‡»è¾“入图片描述

       çº¿ç¨‹A和线程B进行put操作，同样线程A挂起：

       è¯·ç‚¹å‡»è¾“入图片描述

       æ­¤æ—¶çº¿ç¨‹A的运行结果如下：

       è¯·ç‚¹å‡»è¾“入图片描述

       æ­¤æ—¶çº¿ç¨‹B已获得CPU时间片，并完成resize操作：

       è¯·ç‚¹å‡»è¾“入图片描述

       åŒæ ·æ³¨æ„ç”±äºŽçº¿ç¨‹B执行完成，newTable和table都为最新值：5.next=null。

       æ­¤æ—¶åˆ‡æ¢åˆ°çº¿ç¨‹A，在线程A挂起时：e=7，next=5，newTable[3]=null。

       æ‰§è¡Œnewtable[i]=e，就将7放在了table[3]的位置，此时next=5。接着进行下一次循环：

e=5next=e.next ----> next=null，从主存中取值e.next=newTable[1] ----> e.next=5，从主存中取值newTable[1]=e ----> newTable[1]=5e=next ----> e=null

       å°†5放置在table[1]位置，此时e=null循环结束，3元素丢失，并形成环形链表。并在后续操作hashmap时造成死循环。

       è¯·ç‚¹å‡»è¾“入图片描述

       2.jdk1.8中HashMap

       åœ¨jdk1.8中对HashMap进行了优化，在发生hash碰撞，不再采用头插法方式，而是直接插入链表尾部，因此不会出现环形链表的情况，但是在多线程的情况下仍然不安全，这里我们看jdk1.8中HashMap的put操作源码：

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,                   boolean evict) {         Node[] tab; Node p; int n, i;        if ((tab = table) == null || (n = tab.length) == 0)            n = (tab = resize()).length;        if ((p = tab[i = (n - 1) & hash]) == null) // å¦‚果没有hash碰撞则直接插入元素            tab[i] = newNode(hash, key, value, null);        else {             Node 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)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;                    }                    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;    }

       è¿™æ˜¯jdk1.8中HashMap中put操作的主函数， 注意第6行代码，如果没有hash碰撞则会直接插入元素。

       å¦‚果线程A和线程B同时进行put操作，刚好这两条不同的数据hash值一样，并且该位置数据为null，所以这线程A、B都会进入第6行代码中。

       å‡è®¾ä¸€ç§æƒ…况，线程A进入后还未进行数据插入时挂起，而线程B正常执行，从而正常插入数据，然后线程A获取CPU时间片，此时线程A不用再进行hash判断了，问题出现：线程A会把线程B插入的数据给覆盖，发生线程不安全。

       æ€»ç»“

       é¦–å…ˆHashMap是线程不安全的，其主要体现：

       åœ¨jdk1.7中，在多线程环境下，扩容时会造成环形链或数据丢失。

       åœ¨jdk1.8中，在多线程环境下，会发生数据覆盖的情况。