源码解析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>[] 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

源码解析JDK1.8-HashMap链表成环的问题解决方案_第1张图片

  这种计算方式既能保证数据存储散列,又能避免计算出的位置超出最大容量(也就是数组角标越界,因为作&运算,不会超过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)计算后得到的也是这个值。计算原理是相通的。

总结:

  1. jdk1.8 是等链表整个 while 循环结束后,才给数组赋值,此时使用局部变量 loHead 和 hiHead 来保存链表的值,因为是局部变量,所以多线程的情况下,肯定是没有问题的。

  2. 为什么有 loHead 和 hiHead 两个新老值来保存链表呢,主要是因为扩容后,链表中的元素的索引位置是可能发生变化的。

你可能感兴趣的:(源码解析JDK1.8-HashMap链表成环的问题解决方案)