HashMap的底层原理剖析

最新推荐文章于 2022-03-10 15:42:50 发布

一个java小开发

最新推荐文章于 2022-03-10 15:42:50 发布

阅读量225

点赞数 1

文章标签： HashMap底层

本文链接：https://blog.csdn.net/Alice_luvian/article/details/91560454

版权

hashmap的底层原理剖析

今天来讲一下,HashMap的底层原理,在网上也能找到很多博客,其实写的都比较的笼统

1.概述

HashMap是基于Map接口实现，是以Key-Value的方式存储，并且允许使用null（空）建和null（空）值，因为key不允许重复，因此只能有一个键为null（空），在一个就是HashMap不能保证放入元素的顺序，因为它是无序的，所以放入进去的顺序是不相同的，最后就是HashMap是线程不安全的。

(1).数据结构分析

  HashMap的继承关系，继承了AbstractMap，实现了接口。
  给容器设置了（重点） 初始化容量  和  最大容量 ，并且设置了加载因子

	public class HashMapSource<K,V> extends AbstractMap<K,V>
    implements Map<K,V>,Cloneable , Serializable {
    	 //表示默认当前容量为16
      	 static final DEFAULT_INITIAL_CAPACITY = 1 << 4; 
      	 //表示最大容量为1073741824
         static final int MAXIMUM_CAPACITY = 1 << 30;
         //负载因子，当容量达到75%时就进行扩容操作
    	 static final float DEFAULT_LOAD_FACTOR = 0.75f;
    	 //初始化的默认数组
    	 static final Entry<?,?>[] EMPTY_TABLE = {};
		 //HashMap中元素的数量
		 transient int size;
		 //判断是否需要调整HashMap的容量
		 int threshold;

(2).Entry结构分析

在这里插入图片描述
根据上图所画来讲,我们可以发现数据结构是以数组+链表形式组成的。Entry 是 HashMap的内部类，维护着一个Key -Value 映射关系，还有next引用（指向当前table 位置的链表），hash值用来确定每一个Entry链表在 table 中的位置。
下边是HashMap的源码:

static class Entry<K,V> implements Map.Entry<K,V> {
        final K key;
        V value;
        Entry<K,V> next;
        int hash;
        /**
         * Creates new entry.
         */
        Entry(int h, K k, V v, Entry<K,V> n) {
            value = v;
            next = n;
            key = k;
            hash = h;
        }

(3).Hashmap的构造函数

	//构造方法，指定初始容量和负载因子
	public HashMap(int initialCapacity, float loadFactor) {
        //容量不能小于0
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " +                                           initialCapacity);
        //容量不能超出最大容量
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        //加载因子不能<=0 或者 为非数字
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);

        //计算出大于初始容量的最小 2的n次方作为哈希表table的长度，下面会说明为什么要这样
        int capacity = 1;
        while (capacity < initialCapacity)
            capacity <<= 1;

        this.loadFactor = loadFactor;
        //设置HashMap的容量极限，当HashMap的容量达到该极限时就会进行扩容操作
        threshold = (int)Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
        //创建Entry数组
        table = new Entry[capacity];
        useAltHashing = sun.misc.VM.isBooted() &&
                (capacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD);
        init();
    }

 这段代码代表的意思是:
   	 (1）对传入的容量和加载因子进行判断处理。
     (2）设置hashMap的容量极限，当容量达到极限时就会进行 扩容操作。
     (3）计算出大于初始容量的最小 2的n次方作为哈希表table的长度，然后用该长度创建Entry数组。

(4).HashMap中的put操作

put()方法的执行过程如下所示：
在这里插入图片描述
我们结合上面的图来看put的相关操作，我以java1.7为例进行讲解。

   public V put(K key, V value) {
   		if (table == EMPTY_TABLE) { //是否初始化
   	            inflateTable(threshold);
   	        }
   		        //如果key为空的情况
   	        if (key == null)
   	            return putForNullKey(value);
   	        //计算key的hash值
   	        int hash = hash(key);
   	        //计算该hash值在table中的下标
   	        int i = indexFor(hash, table.length);
   	        //对table[i]存放的链表进行遍历
   	        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
   	            Object k;
   	            //判断该条链上是否有hash值相同的(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;
   	            }
   	        }
   	
   	        //修改次数+1
   	        modCount++;
   	        //把当前key，value添加到table[i]的链表中
   	        addEntry(hash, key, value, i);
   	        return null;
       }

以上总结:
	1. 判断table是否初始化，如果没有就进行初始化   (分配空间，Entry[]数组的长度)。
	2. 判断key是否为null，如果key==null ,放置在Entry[]的0号位置。
	3. 计算在Entry[]数组的存储位置，判断该位置上是否已有元素，如果已经有元素存在，则遍历该Entry[]数组位置上的单链表。
	4. 判断key是否存在，如果key已经存在，则用新的value值，替换点旧的value值，并将旧的value值返回。
	5. 如果key不存在于HashMap中，程序继续向下执行。将key-vlaue, 生成Entry实体，添加到HashMap中的Entry[]数组中。
	6. 添加到方法的具体操作，在添加之前先进行容量的判断，如果当前**容量达到了阈值**，并且需要存储到Entry[]数组中，先进性扩容操作，扩容的**容量为table长度的2倍**。
	7. 重新计算hash值，和数组存储的位置，**扩容后的链表顺序与扩容前的链表顺序相反**。
	8. 然后将**新添加的Entry实体存放到当前Entry[]位置链表的头部**。

在这里做一个说明: 
	在1.8之前，新插入的元素都是放在了链表的头部位置，但是这种操作在高并发的环境下容易导致死锁，所以1.8之后，新插入的元素都放在了链表的尾部。

补充一下1.8的源码:

public V put(K key, V value) {
    //调用putVal()方法完成
    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;
    //计算存储的索引位置，如果没有元素，直接赋值
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    else {
        Node<K,V> 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<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);
                    //链表长度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;
        }
    }
    //记录修改次数
    ++modCount;
    //判断是否需要扩容
    if (++size > threshold)
        resize();
    //空操作
    afterNodeInsertion(evict);
    return null;
}

借鉴一下别人的总结原文链接:https://www.jianshu.com/p/3bf097f4cf0a 来源：简书

如果当前map中没有数据，执行resize方法
如果要插入的键值对要存放的位置上刚好没有元素，那么就把它封装成Node对象，并放在这个位置上。
如果发生碰撞，判断node的类型是红黑树还是链表：
3.1 如果为红黑树，则将K-V对插在红黑树对应的位置。
3.2 如果为链表，遍历链表：
　a.如果为链表最后一个node ,则将新的node节点插入到链表尾
b.插入完，如果链表的node数量大于8，则将链表转为红黑树的操作；如果当前哈希表为空或数组长度小于64，会扩容，否则转化为红黑树。转化的过程：先遍历链表，将链表的节点转化为红黑树的节点；然后将链表转化为红黑树。
c.遍历链表时，如果key已存在，则直接bredk循环。
判断是否要扩容
返回

HashMap扩容机制

在HashMap中有一下两个属性和扩容相关：
		int threshold;
        final float loadFactor;
		其中threshold = Length * loadFactor，Length表示table数组的长度(默认值是16)，loadFactor为负载因子(默认值是0.75)，
		阀值threshold表示当table数组中存储的元素超过这个阀值的时候，就需要扩容了。
		以默认长度16，和默认负载因子0.75为例，threshold = 16 * 0.75 = 12，即当table数组中存储的元素个数超过12个的时候，table数组就该扩容了。

其中就引出了一个问题:
Java中的数组是无法自动扩容的，方法是使用一个新的数组代替已有的容量小的数组，然后将旧数组中的元素经过重新计算放到新数组中，那么怎样对旧元素进行重新映射呢？

由于我们在扩容时，是使用2的幂扩展，即数组的长度扩大到原来的2倍, 4倍, 8倍…，因此在resize时(Length - 1)这部分相当于在高位新增一个或多个1bit，我们以扩大到原来的两倍为例说明：
在这里插入图片描述

(a)中n为16，(b)中n扩大到两倍为32，相当于(n - 1)这部分的高位多了一个1, 然后和原hash码作与操作，这样元素在数组中映射的位置要么不变，要不向后移动16个位置：

因此，我们在扩充HashMap的时候，只需要看看原来的hash值新增的那个bit是1还是0就好了，是0的话索引没变，是1的话索引变成“原索引+oldCap”，可以看看下图为16扩充为32的resize示意图：
在这里插入图片描述
由于新增的1bit是0还是1可以认为是随机的，因此resize的过程，均匀的把之前的冲突的节点分散到新的bucket了。这一块就是JDK1.8新增的优化点。有一点注意区别，JDK1.7中resize的时候，旧链表迁移新链表的时候，如果在新表的数组索引位置相同，则链表元素会倒置，但是从上图可以看出，JDK1.8不会倒置。

HashMap的put方法:

	  public V get(Object key) {
        //如果key为null，求null键
        if (key == null)
            return getForNullKey();
        // 用该key求得entry
        Entry<K,V> entry = getEntry(key);

        return null == entry ? null : entry.getValue();
    }
    final Entry<K,V> getEntry(Object key) {
        int hash = (key == null) ? 0 : hash(key);
        for (Entry<K,V> e = table[indexFor(hash, table.length)];
             e != null;
             e = e.next) {
            Object k;
            if (e.hash == hash &&
                ((k = e.key) == key || (key != null && key.equals(k))))
                return e;
        }
        return null;
    }

（1）如果 key 为 null, 求null 键
（2）key 不为null , 调用hash(key) ,求得key对应的hash值，然后调用indexFor(hash) 求得hash 值对应的table的索引位置，然后遍历索引位置的链表，如果存在key, 则把key 对应的Entry 返回，否则返回null 。

HashMap死锁形成原理

HashMap非线程安全，即任一时刻可以有多个线程同时写HashMap，可能会导致数据的不一致。如果需要满足线程安全，可以用 Collections的synchronizedMap方法使HashMap具有线程安全的能力，或者使用线程安全的ConcurrentHashMap。

要理解HashMap死锁形成的原理，我们要对HashMap的resize里的transfer过程有所了解，transfer过程是将旧数组中的元素复制到新数组中，在Java 8之前，复制过程会导致链表倒置，这也是形成死锁的重要原因（Java 8中已经不会倒置），transfer的基本过程如下：

1. 新建节点e指向当前节点，新建节点next指向e.next
2. 将e.next指向新数组中指定位置newTable[i]
3. newTable[i] = e
4. e = next

举栗:

现在有链表1->2->3，要将它复制到新数组的newTable[i]位置
1. Node e = 1, next = e.next;
2. e.next = newTable[i];
3. newTable[i] = e;
4. e = next, next = e.next;
执行完后会得到这样的结果：
newTable[i]=3->2->1

死锁会在这种情况产生：两个线程同时往HashMap里放Entry，同时HashMap正好需要扩容，如果一个线程已经完成了transfer过程，而另一个线程不知道，并且又要进行transfer的时候，死锁就会形成。

总结:

扩容是一个特别耗性能的操作，所以当程序员在使用HashMap的时候，估算map的大小，初始化的时候给一个大致的数值，避免map进行频繁的扩容。
负载因子是可以修改的，也可以大于1，但是建议不要轻易修改，除非情况非常特殊。
HashMap是线程不安全的，不要在并发的环境中同时操作HashMap，建议使用ConcurrentHashMap。
JDK1.8引入红黑树大程度优化了HashMap的性能。

一个java小开发

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
HashMap的底层原理剖析

hashmap的底层原理剖析1.概述大家好，我是一个博客小白，第一次写博客，请大佬们多多指教。HashMap是Key-Value数据存储结构，维护了一个Entry entry是一个数组，而在每一个Entry数组中又维护了一个Node节点，每一个Node节点中包含了上一个节点的信息以及下一个节点的指针。数据结构分析 HashMap的继承关系，继承了AbstractMap，实现了接...
复制链接

扫一扫