源码解析JDK1.8-HashMap链表成环的问题解决方案

最新推荐文章于 2024-05-07 11:35:56 发布

置顶程序员清辞

最新推荐文章于 2024-05-07 11:35:56 发布

阅读量2k

点赞数 3

分类专栏：面试现场文章标签： java 算法链表

本文链接：https://blog.csdn.net/someone77/article/details/108109456

版权

面试现场专栏收录该内容

3 篇文章 0 订阅

订阅专栏

	上篇文章详解介绍了HashMap在JDK1.7版本中链表成环的原因，今天介绍下JDK1.8针对HashMap线程安全问题的解决方案。

jdk1.8 扩容源码解析

public class HashMap<K,V> extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable {
    
    // jdk1.8 HashMap扩容源码
	final Node<K,V>[] resize() {
        
        Node<K,V>[] oldTab = table;
        
        // 到@SuppressWarnings都是计算newTab的newCap和threshold容量
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        int oldThr = threshold;
        int newCap, newThr = 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
        }
        else if (oldThr > 0) // initial capacity was placed in threshold
            newCap = oldThr;
        else {               // zero initial threshold signifies using defaults
            newCap = DEFAULT_INITIAL_CAPACITY;
            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<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
        
        // 开始进行数据迁移
        table = newTab;
        if (oldTab != null) {
            // 遍历oldTab中的数据，并迁移到新数组。
            for (int j = 0; j < oldCap; ++j) {
                Node<K,V> e;
                // 如果oldTab数组中j位置数据不为null，进行遍历，并赋值给e，避免直接对oldTab进行操作
                if ((e = oldTab[j]) != null) {
                    oldTab[j] = null;
                    // 如果oldTab的j位置数据没有形成链表，就直接赋值到newTab
                    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
                        // loHead 表示老值,老值的意思是扩容后，该链表中计算出索引位置不变的元素
                        Node<K,V> loHead = null, loTail = null;
                        // hiHead 表示新值，新值的意思是扩容后，计算出索引位置发生变化的元素
                        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;
    }
}

看完上边的代码后，可能也是一头雾水，下面我们重点对其中的细节点进行解析，针对计算newTab的newCap和threshold容量部分我们就不详细阐述，重点从数据迁移部分进行分析。我们按照代码顺序分步进行分析。

1、利用for循环遍历oldTab中的数据

for (int j = 0; j < oldCap; ++j) {
	Node<K,V> e;

2、对oldTab在j位置的数据进行判断，并进行数据迁移操作

如果在oldTab的j位置数据没有形成链表

if (e.next == null)
	newTab[e.hash & (newCap - 1)] = e;

如果e.next == null，也就是e没有next数据节点，通过这种方法判断是否形成了链表数据结构，如果没有形成链表数据结构，直接将数据放到对应newTab的位置即可。

e.hash & (newCap - 1) : 代表newTab存放e数据的位置，假如，e.hash = 5，oldCap = 4（老数组oldTab的长度），newCap = 8（新数组newTab的长度，即老数组2倍扩容），那么该e元素：在oldTab中的位置为：5 & (4 - 1) = 1

101

& 11

001

在newTab中的位置为：5 & (8 - 1) = 5

101

& 111

101

在这里插入图片描述
这种计算方式既能保证数据存储散列，又能避免计算出的位置超出最大容量（也就是数组角标越界，因为作&运算，不会超过oldTab-1和newTab-1）。

3、链表转换成了红黑树，针对红黑树的迁移方式

else if (e instanceof TreeNode)
	((TreeNode<K,V>)e).split(this, newTab, j, oldCap);

具体的遍历方式赞不做解析，如想了解更多，请关注公众号“程序员清辞”。

4、针对链表的数据迁移方式

else { // preserve order
	// loHead 表示老值,老值的意思是扩容后，该链表中计算出索引位置不变的元素
	Node<K,V> loHead = null, loTail = null;
	// hiHead 表示新值，新值的意思是扩容后，计算出索引位置发生变化的元素
	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);
}

jdk1.8版本为了提高链表迁移的效率，引用两个新的概念：

loHead：表示老值,老值的意思是扩容后，该链表中计算出索引位置不变的元素。

hiHead：表示新值，新值的意思是扩容后，计算出索引位置发生变化的元素。

举个例子，数组大小是 8 ，在数组索引位置是 1 的地方挂着一个链表，链表有两个值，两个值的 hashcode 分别是是9和33。当数组发生扩容时，新数组的大小是 16，此时 hashcode 是 33 的值计算出来的数组索引位置仍然是 1，我们称为老值hashcode 是 9 的值计算出来的数组索引位置是 9，就发生了变化，我们称为新值。

针对链表做do-while遍历，条件为(e = next) != null。利用(e.hash & oldCap) == 0来判断元素e属于新值链表还是老值链表。参考上面索引位置计算算法 e.hash & (oldCap - 1)，这次直接利用e.hash与oldCap作&运算，因为oldCap为4、8、16…为2的指数，其二进制为100，1000，10000…，所以e.hash与其作&运算，假如oldCap = 4，newCap = 8，那么最终计算得到的值如果等于0，则该元素的位置0_{3之间，除此之外在4}7之间。通过这种方式判断元素e属于老值还是新值，这样生成两条新的链表。

5、生成新老链表后整体赋值

// 老链表整体赋值
if (loTail != null) {
	loTail.next = null;
	newTab[j] = loHead;
}
// 新链表整体赋值
if (hiTail != null) {
	hiTail.next = null;
	newTab[j + oldCap] = hiHead;
}

如果是老链表，直接将数据赋值给newTab[j]。如果是新链表，需要进行将j增加oldCap的长度，通过e.hash & (newTab - 1)计算后得到的也是这个值。计算原理是相通的。

总结：

jdk1.8 是等链表整个 while 循环结束后，才给数组赋值，此时使用局部变量 loHead 和 hiHead 来保存链表的值，因为是局部变量，所以多线程的情况下，肯定是没有问题的。
为什么有 loHead 和 hiHead 两个新老值来保存链表呢，主要是因为扩容后，链表中的元素的索引位置是可能发生变化的。

程序员清辞

关注

3
点赞
踩
7

收藏

觉得还不错? 一键收藏
2
评论
源码解析JDK1.8-HashMap链表成环的问题解决方案

上篇文章详解介绍了HashMap在JDK1.7版本中链表成环的原因，今天介绍下JDK1.8针对HashMap线程安全问题的解决方案。jdk1.8 扩容源码解析public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable { // jdk1.8 HashMap扩容源码 final Node<K,V>.
复制链接

扫一扫