【java】hashMap的底层原理

Faquir_Ying
已于 2022-04-16 21:54:11 修改
阅读量172
点赞数
分类专栏： java 文章标签： java
于 2022-04-05 18:35:46 首次发布
本文链接：https://blog.csdn.net/W_Ying_/article/details/123965061
版权
java 专栏收录该内容
5 篇文章 0 订阅
订阅专栏
本文深入解析HashMap的扩容与树化过程，包括首次添加元素时的扩容策略、链表转红黑树的条件，以及多线程环境下可能出现的问题。分析了为何加载因子设为0.75，何时将链表转为红黑树，以及为何选择特定阈值的原因。同时探讨了HashMap在多线程环境下的不安全性及其解决方案。
摘要由CSDN通过智能技术生成
                    
                        
                    
                    问题描述 
 
初识HashMap从HashSet的扩容机制谈起
源码：	Set set = new HashSet<>();
	set.add("张大帅");
	set.add("张少帅");
	set.add("张大帅");
	
	// 1、调用无参构造器 返回在HashSet中初始化HashMap对象
	public HashSet(){
    	map = new HashMap();
    }
	
	// 2、调用HashSet的add方法
	public boolean add(E e) {
		// PRESENT是hashSet的静态对象 用于占位 
	    // Dummy value to associate with an Object in the backing Map
        return map.put(e, PRESENT)==null;  
    }
    
     // 3、调用hashMap的put方法 hash值作为table的索引
     public V put(K key, V value) { // key=“张大帅” value = static final new Object();
          return putVal(hash(key), key, value, false, true);
     }
	 
	 // 4、计算hash值，使用key的hashCode值及hashCode值无符号右移16做异或运算的结果，目的是减少hash冲突
	 static final int hash(Object key) {
     	int h;
     	// key不为空，key的hashCode
     	// ^ 表示异或运算：相同置0，不同置1
     	// >>> 16 右移16位 高16位可以减少hash冲突
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16); 
     }
     // 5、HashMap 的 putVal() 方法
     /**
    * Implements Map.put and related methods
     *
     * @param hash hash for key
     * @param key the key
     * @param value the value to put
     * @param onlyIfAbsent if true, don't change existing value
     * @param evict if false, the table is in creation mode.
     * @return previous value, or null if none
     */
    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        // 1、辅助变量初始化
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        // 2、table 是 HashMap的一个属性 类型为 Node[]
        //   判断当前table为空 或者 tab.length == 0, 执行resize()table扩容方法
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        // 3、根据key得到hash索引值，找到key在table对应的位置索引位置 
             // 并且 把这个位置的对象赋给p 
        // 4、p是否为null
        if ((p = tab[i = (n - 1) & hash]) == null)
        	// 如果p为空 表示当前位置没有存放元素，
        	// 新建一个该key的Node对象 Node（key="张大帅"value=PRESENT）
            tab[i] = newNode(hash, key, value, null);
        else {
        	// p不为空，代表当前table索引位置存在 单链表
            Node<K,V> e; K k;
            // 判断 当前数组位置的第一个Node节点key与传入key作比较
            // 满足：（1）两者hash值相等
            //      （2）两者引用地址或值相等
            // 则认为 传入的key存在 
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            // 判断 当前节点是TreeNode的实例，将table转为红黑树
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
            	// 当前链表已存在，for循环指向下一节点
                for (int binCount = 0; ; ++binCount) {
                	// 下节点为空，没有发现相同的key，就自动加到链表末尾，跳出
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        // 追加节点结束后，当前链表长度大于等于8，对当前列表进行树化，转为红黑树
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    // 判断key是否相同，相同跳出
                    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;
            }
        }
        // 操作数+1
        ++modCount;
        // node数是否超过临界长度
        if (++size > threshold)
        	// 超过扩容
            resize();
        // 留给子类实现链表排序的方法，默认
        afterNodeInsertion(evict);
        return null;
    }

    /**
     * Initializes or doubles table size.  If null, allocates in
     * accord with initial capacity target held in field threshold.
     * Otherwise, because we are using power-of-two expansion, the
     * elements from each bin must either stay at same index, or move
     * with a power of two offset in the new table.
     *
     * @return the table
     */
    final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;
        // 旧容量值
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        // 旧的临界值
        int oldThr = threshold;
        // 初始化新的容量和临界值
        int newCap, newThr = 0;
        // 旧的容量值大于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
        }
        // 旧的临界值大于0
        else if (oldThr > 0) // initial capacity was placed in threshold
            newCap = oldThr;
        // 两者均为0
        else {               // zero initial threshold signifies using defaults
            newCap = DEFAULT_INITIAL_CAPACITY; // 新的容量 默认 16
            // 新的临界值 = 加载因子（0.75）* 默认容量值
            // 如果当前table数组使用已达到临界值，就扩容
            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数组，作为链表
        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;
    }

    /**
     * Replaces all linked nodes in bin at index for given hash unless
     * table is too small, in which case resizes instead.
     */
    final void treeifyBin(Node<K,V>[] tab, int hash) {
        int n, index; Node<K,V> e;
        // 表为空或者 表的实际长度 小于 链表转红黑树的最小容量（1 >> 4）64 
        // 只对表的长度进行扩展
        if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
            resize();
        else if ((e = tab[index = (n - 1) & hash]) != null) {
            TreeNode<K,V> hd = null, tl = null;
            do {
                TreeNode<K,V> p = replacementTreeNode(e, null);
                if (tl == null)
                    hd = p;
                else {
                    p.prev = tl;
                    tl.next = p;
                }
                tl = p;
            } while ((e = e.next) != null);
            if ((tab[index] = hd) != null)
                hd.treeify(tab);
        }
	}
 
 
hashMap问题 
 
hashMap的特点 
  由于hash桶+单向链表+红黑树的底层结构，存取是无序的
key和value都可以为null，但key只有一个为null值
key是唯一的
jdk1.8之前为数组+单向链表，jdk1.8之后为数组+单向链表+红黑树
 
hashMap的扩容与树化机制： 
  首次添加元素时，table数组扩容到16，其threshold(临界值)=capacity(当前容量)*loadFactory(加载因子)，即当前临界值为12
往后数组元素达到临界值时，每次扩容到原来的两倍，临界值更新为当前容量的0.75倍
当单条链表上的元素达到treefiy_threshold，并且table的大小大于等于MIN_TREEIFY_CAPACITY(最小树化容量)，会转为红黑树，否则仍然扩容。
扩容触条件： 
    空数组
table数组达到临界值
总结点达到临界值
单链达到8个
 
元素减少又会退化成单向链表，出于对time and space的综合考虑
 
hashMap的put流程 
  获得key的hash值：h = key.hashCode()) ^ (h >>> 16）
针对得到的int hash值： 
    hash值不存在，把key-value封装为Node对象，存放到数组的相应索引位置
如何hash值相等，则调用key的equals方法比较，头节点key相等则更新value
如果时TreeNode则直接树化
否则与该链表上的节点以此比较，如相等，更新value，否则Node尾插
 
 
jdk1.7中HashMap在多线程场景下为什么会出现死循环？解决方案是什么？ 
  死循环：		假设两个线程T1、T2都对HashMap进行扩容 
		T1 = A
		T1.next = B
		T2 = A	
		T2.next = B
		如果此时线程T2的时间片用完了，
		T1单独执行，依据头插法，将链表A->B->C，重新扩容为C->B->A
		T2休眠结束，按照初始指向A->B，顺序为A->B->C，顺序刚好相反，由此产生死循环
		为此1.8之后改为了尾插法
 
解决办法： 
    使用线程安全的ConcurrentHashMap(推荐)
使用hashtable, 效率低，不推荐
使用synchronized或Lock方式会影响性能，不推荐
 
 
解决hash冲突的办法有哪些?HashMap用的哪种？ 
  开放定址法、再哈希法、链地址法、建立公共溢出区，hashMap使用的是链地址法
开放地址法：p=H(key)出现冲突时，则以p为基础，再次hash，p1=H§，直到不冲突为止，hash表的容量必须大于等于当前元素个数，因为存在再次hash，所以只能在删除的节点上做标记，而不能真正删除节点
再哈希法：使用多个散列算法，降低冲突，这样做虽然不易产生堆集，但增加了计算的时间
链表法：将哈希值相同的元素构成一个同义词的单链表，并将单链表的头指针存放在哈希表的第i个单元中，查找、插入和删除主要在同义词链表中进行，链表法适用于经常进行插入和删除的情况。
建立公共溢出区，将哈希表分为公共表和溢出表，当溢出发生时，将所有溢出数据统一放到溢出区
 
为什么要在数组长度大于64之后，链表才会进化为红黑树 
  在数组比较小时如果出现红黑树结构，反而会降低效率，而红黑树需要进行左旋右旋，变色，这些操作来保持平衡，同时数组长度小于64时，搜索时间相对要快些，总之是为了加快搜索速度，提高性能
当数组长度大于64，并且单链节点数超过8，转为红黑树，时间复杂度由o(n)变为o(logn)，使得查询得到优化
 
为什么加载因子设置为0.75，初始化临界值是12？ 
  thrsehold是hashMap所能容纳的元素最大值，当临界值越大，容量节点自然越多
当加载因子趋于1时，数据会比较密集，查询效率会降低，而且新增时更容易出现hash冲突，效率也会降低
当加载因子趋于0时，数据比较稀疏浪费内存空间
所以0.75是对时间和空间的一种平衡选择
 
哈希表如何计算hash值的 
  hashCode方法是Object中的方法，所有的类都可以对其进行使用，首先底层通过调用hashCode方法生成初始hash值h1，然后将h1无符号右移16位得到h2，之后将h1与h2进行按位异或（^）运算得到最终hash值h3，之后将h3与(length-1)进行按位与（&）运算得到hash表索引值
 
如果两个对象的hashCode相等时： 
  hashcode相等时，会产生hash碰撞，之后调用equals方法进行比较，如果内容相等，进行value覆盖，否则，插到单链表尾部，链表长度超过8且数组长度超过64，变成红黑树
 
一般用什么作为HashMap的key？ 
  一般用Integer、String这种不可变类当HashMap当key
因为String是不可变的，当创建字符串时，它的hashcode被缓存下来，不需要再次计算，相对于其他对象更快
因为获取对象的时候要用到equals()和hashCode()方法，那么键对象正确的重写这两个方法是非常重要的，这些类很规范的重写了hashCode()以及equals()方法
 
为什么Map桶中节点个数超过8才转为红黑树？ 
  树节点占用空间是普通Node的两倍，如果链表节点不够多却转换成红黑树，无疑会耗费大量的空间资源，并且在随机hash算法下的所有bin节点分布频率遵从泊松分布，链表长度达到8的概率只有0.00000006，几乎是不可能事件，所以8的计算是经过重重科学考量的
从平均查找长度来看，红黑树的平均查找长度是logn，如果长度为8，则logn=3，而链表的平均查找长度为n/4，长度为8时，n/2=4，所以阈值8能大大提高搜索速度
当长度为6时红黑树退化为链表是因为logn=log6约等于2.6，而n/2=6/2=3，两者相差不大，而红黑树节点占用更多的内存空间，所以此时转换最为友好
 
HashMap为什么线程不安全？ 
  多线程下扩容死循环。JDK1.7中的HashMap使用头插法插入元素，在多线程的环境下，扩容的时候有可能导致环形链表的出现，形成死循环。因此JDK1.8使用尾插法插入元素，在扩容时会保持链表元素原本的顺序，不会出现环形链表的问题
多线程的put可能导致元素的丢失。多线程同时执行put操作，如果计算出来的索引位置是相同的，那会造成前一个key被后一个key覆盖，从而导致元素的丢失。此问题在JDK1.7和JDK1.8中都存在
put和get并发时，可能导致get为null。线程1执行put时，因为元素个数超出threshold而导致rehash，线程2此时执行get，有可能导致这个问题，此问题在JDK1.7和JDK1.8中都存在
 
currentHashMap是如何做到线程安全的？ 
  待学习整理
 

                
Faquir_Ying
关注
0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
【java】hashMap的底层原理

问题描述初识HashMap从HashSet的扩容机制谈起源码： Set set = new HashSet<>(); set.add("张大帅"); set.add("张少帅"); set.add("张大帅"); // 1、调用无参构造器返回在HashSet中初始化HashMap对象 public HashSet(){ map = new HashMap(); } // 2、调用HashSet的add方法 public boolean add(E
复制链接

扫一扫
专栏目录