基础 / JavaSE
21 分钟 读完 (大约 3206 个字) 0次访问

初试HashMap的put存储过程

在正式深入了解HashMap之前，我们先按照一个简单的例子来走一遍HashMap的put方法的存储过程。

案例

1
2
3
HashMap<String,Object> hashMap = new HashMap<>();
hashMap.put("name","ooyhao");
hashMap.put("gender","男");

源码分析

下面我们通过分析上面的两行代码，来进行源码分析。

首先是调用无参构造方法来实例化HashMap对象。如下，这是将默认的负载因子0.75赋值给实例化的对象的loadFactor属性。

1
2
3
4
5
6
7
8
/**
 * Constructs an empty <tt>HashMap</tt> with the default initial capacity
 * (16) and the default load factor (0.75).
 * 无参构造方法，使用默认的初始化容量16 和 默认的负载因子0.75 实例化HashMap
 */
public HashMap() {
    this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}

下面我们开始执行put方法存储key-value。

1
2
3
public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
}

执行put方法，实际上调用的putVal方法，这里可以看到，在执行putVal方法之前，对key进行了hash值的计算。

1
2
3
4
static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

然后执行putVal方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;//resize 扩容 [无参，第一次put，初始化为16]
    if ((p = tab[i = (n - 1) & hash]) == null)
        //创建一个节点，放置在tab的第i个位置上。
        tab[i] = newNode(hash, key, value, null);
    else {//如果不为null，即表示当前数组位置上已经存在了值，发生了Hash冲突。
        Node<K,V> e; K k;
        //p就是冲突的第一个位置。hash值相同，key相同，或者equals。表示key相同。
        //注意：相同的hash可能对应不同的key
        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 {//链表[如果不是同一个元素，即hash冲突，但是key不同，并且此时不是树结构，则执行链表结构]
            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  TREEIFY_THRESHOLD - 1 = 7 如果
                        //当链表添加到第8个时，就会触发树型化操作，即将链表转为红黑树。那这里其实可以知道，链表存在的最长的串就是7个。
                        // 8个节点是一个临界值。
                        treeifyBin(tab, hash);
                    break;
                }
                if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))
                    break;//同样，如果存在一样的key，则跳过
                p = e;//相当于p=p.next
            }
        }
        if (e != null) { // existing mapping for key
            V oldValue = e.value;
            //onlyIfAbsent为false，或oldValue为null, 才会执行覆盖操作
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;//值覆盖
            afterNodeAccess(e);
            return oldValue;//返回oldValue
        }
    }
    ++modCount;//并发操作，fast-fail
    if (++size > threshold)//size+1
        resize();
    afterNodeInsertion(evict);
    return null;
}

这个方法就是put方法的重点了。一开始下面的条件是成立的，因为第一次put的时候，table还是null。

1
if ((tab = table) == null || (n = tab.length) == 0)

由于上面的判断是成立的，所以会走到扩容方法resize：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
final Node<K,V>[] resize() {
    Node<K,V>[] oldTab = table;//null
    int oldCap = (oldTab == null) ? 0 : oldTab.length;//0
    int oldThr = threshold;//0
    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){
            // newCap = oldCap << 1 扩容机制，新的容量是旧容量的2倍，新的阈值也是旧的阈值的两倍
            newThr = oldThr << 1;
        }
    } else if (oldThr > 0){
        newCap = oldThr;//8
    } else {               // zero initial threshold signifies using defaults
        newCap = DEFAULT_INITIAL_CAPACITY;//16
        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);//12
    }
    if (newThr == 0) {
        float ft = (float)newCap * loadFactor;//16 * 0.75 = 12
        newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ? (int)ft : Integer.MAX_VALUE);//12
    }
    threshold = newThr;//6
    @SuppressWarnings({"rawtypes","unchecked"})
    Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];//创建一个Node类型的数组。
    table = newTab;//复制给HashMap的table属性
    if (oldTab != null) {
        for (int j = 0; j < oldCap; ++j) {//遍历数组
            Node<K,V> e;
            if ((e = oldTab[j]) != null) {//数组的第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;//low
                    Node<K,V> hiHead = null, hiTail = null;//high
                    Node<K,V> next;
                    do {
                        next = e.next;
                        if ((e.hash & oldCap) == 0) {//如果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;
}

这个方法可以看到，其实也挺复杂，但是第一次初始化扩容时，我们将不相关的代码先删除：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
final Node<K,V>[] resize() {
    //一开始 table==null
    Node<K,V>[] oldTab = table;
   	//所以oldCap == 0
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    //threshold也是0
    int oldThr = threshold;
    int newCap, newThr = 0;
    if (oldCap > 0) {
        //不成立
    } else if (oldThr > 0){
        //也不成立
    } else { // 执行
        //默认初始化容量为16
        newCap = DEFAULT_INITIAL_CAPACITY;
        //负载因子为0.75，所以新的阈值为12
        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
    }
    if (newThr == 0) {
        //不执行
    }
    //将对象的阈值设置为12
    threshold = newThr;//12
    @SuppressWarnings({"rawtypes","unchecked"})
    //创建一个Node类型的数组。【重点】
    Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
    //复制给HashMap的table属性
    table = newTab;
    if (oldTab != null) {
        //不执行，oldTab == null
    }
    return newTab;
}

这样看起来，首次扩容其实也不是很难。完成了阈值threshold的设定，以及数组table的创建。

继续：

执行完扩容，就执行下面这个判断：

1
if ((p = tab[i = (n - 1) & hash]) == null)

这里需要注意的是 (n - 1) & hash 这个其实就相当于取模运算。

我们假设hash值计算得为18，此时n=16.下面计算与运算：

1
2
3
4
0000 0000 0000 0000 0000 0000 0001 0010 =>18
0000 0000 0000 0000 0000 0000 0000 1111 => n-1=15
--------------------------------------- & (1&1=0; 0&1=0; 1&0=0; 0&0=0)
0000 0000 0000 0000 0000 0000 0000 0010 => 2

可以看到，相当于对16取模。得到了2. 为什么对16取模呢，因为此时table的长度就是16，所以需要对hash值进行取模，然后分布到16个数组元素上。

我们可以知道，此时位置i上是没有元素，所以if ((p = tab[i = (n - 1) & hash]) == null) 为true。创建一个新的节点：

1
2
 //创建一个节点，放置在tab的第i个位置上。
tab[i] = newNode(hash, key, value, null);

这里我们在看看这个节点的结构：

1
2
3
4
5
6
static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;
        final K key;
        V value;
        Node<K,V> next;
}

创建节点之后，并将其放置到第i个位置上，然后执行：

1
2
if (++size > threshold)//size+1
    resize();

由于新增加了一个节点，所以需要size++，但是此时size=1，还达不到阈值12，所以不需要重新扩容，返回null，可以看到。刚开始第一个元素put进行时，其实过程分析下来不是很难。

那下面我们再分析第二次put的过程:

同样是调用putVal方法：

此时执行，条件if ((tab = table) == null || (n = tab.length) == 0) 就不在成立。

同样，执行与&运算，此时我们假设”gender”字符串的hashcode的值为19，那此时 i =(n-1)&hash的值就是3. 同样，在第3个位置上创建一个新的节点。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    if ((tab = table) == null || (n = tab.length) == 0)
       //不执行
    if ((p = tab[i = (n - 1) & hash]) == null)
        //创建一个节点，放置在tab的第i个位置上。
        tab[i] = newNode(hash, key, value, null);
    else {
        //不执行
    }
    ++modCount;//并发操作，fast-fail
    if (++size > threshold)//size+1
        resize();
    afterNodeInsertion(evict);
    return null;
}

下面我们研究一下，下面的语句的执行过程：

1
2
3
HashMap<String,Object> hashMap = new HashMap<>();
hashMap.put("1","1");
hashMap.put("A","A");

第一步：hash值的计算

首先，我们先通过其计算，可以得出它们的hashcode：

1
2
0011 0001 => 1 =>49
0100 0001 => A =>65

我们通过hash方法之后，得到的结果还是这个：

1
2
3
4
5
6
7
8
9
0000 0000 0000 0000 0000 0000 0011 0001
0000 0000 0000 0000 0000 0000 0000 0000 >>>16
--------------------------------------- ^ (同0异1)
0000 0000 0000 0000 0000 0000 0011 0001

0000 0000 0000 0000 0000 0000 0100 0001
0000 0000 0000 0000 0000 0000 0000 0000 >>> 16
--------------------------------------- ^
0000 0000 0000 0000 0000 0000 0100 0001

同样，一开始，条件if ((tab = table) == null || (n = tab.length) == 0) 是成立的，然后执行首次扩容方法，上面已经分析，这里不再赘述：

1
2
if ((tab = table) == null || (n = tab.length) == 0)
	n = (tab = resize()).length;//resize 扩容 [无参，第一次put，初始化为16]

此时n=16. 条件 if ((p = tab[i = (n - 1) & hash]) == null) 也是成立的。我们根据上面的hash值与n-1做与运算可以得到结果都是1，如下：

1
2
3
4
5
6
7
8
9
0000 0000 0000 0000 0000 0000 0011 0001 => "1"
0000 0000 0000 0000 0000 0000 0000 1111 => n-1=15
--------------------------------------- &
0000 0000 0000 0000 0000 0000 0000 0001 => 1
    
0000 0000 0000 0000 0000 0000 0100 0001 => "A"
0000 0000 0000 0000 0000 0000 0000 1111 => n-1=15
--------------------------------------- &
0000 0000 0000 0000 0000 0000 0000 0001 => 1

第一次执行put("1","1") 将这对键值对放置在 数组为1 的位置上。存储过程就不再分析，我们这里主要分析发送hash冲突的时候，怎么解决。即，当我们put第二个key的时候。

第二次执行put的时候，条件if ((p = tab[i = (n - 1) & hash]) == null) 不再成立。此时位置1上已经有值了。

执行else里面的内容：

条件 if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) 是false，因为此时hash值不一样，继续执行，此时节点p不是一个树节点（后续讲）。执行else。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
else {//如果不为null，即表示当前数组位置上已经存在了值，发生了Hash冲突。
    Node<K,V> e; K k;
    //p就是冲突的第一个位置。hash值相同，key相同，或者equals。表示key相同。
    //注意：相同的hash可能对应不同的key，但是不同的key的hash值肯定不一样
    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 {//链表[如果不是同一个元素，即hash冲突，但是key不同，并且此时不是树结构，则执行链表结构]
        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  TREEIFY_THRESHOLD - 1 = 7 如果
                    //当链表添加到第8个时，就会触发树型化操作，即将链表转为红黑树。那这里其实可以知道，
                    //链表存在的最长的串就是7个。
                    // 8个节点是一个临界值。
                    treeifyBin(tab, hash);
                break;
            }
            if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))
                break;//同样，如果存在一样的key，则跳过
            p = e;//相当于p=p.next
        }
    }
    if (e != null) { // existing mapping for key
        V oldValue = e.value;
        //onlyIfAbsent为false，或oldValue为null, 才会执行覆盖操作
        if (!onlyIfAbsent || oldValue == null)
            e.value = value;//值覆盖
        afterNodeAccess(e);
        return oldValue;//返回oldValue
    }
}

执行else代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
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  TREEIFY_THRESHOLD - 1 = 7 如果
            //当链表添加到第9个时，就会触发树型化操作，即将链表转为红黑树。那这里其实可以知道，
            //链表存在的最长的串就是8个。
            treeifyBin(tab, hash);
        break;
    }
    if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))
        break;//同样，如果存在一样的key，则跳过
    p = e;//相当于p=p.next
}

注释也解释的挺明白，因为jdk8是采用数据+链表+红黑树。一开始是形成链表的，等到长度大于8时，才会进行树形化。也就是上面的treeifyBin 方法。当(e = p.next) == null 成立时，其实就是遍历到最后一个节点。然后创建一个新的节点接到尾节点上。

这里可以看到，当记性hash碰撞的时候，并且此时已存在的链表长度不大于8，则以链表的形式存在，如果当原有节点是7时，再次新添加节点后，就会触发树形化，即在原有链表的结构上，增加一层树形结构。即此时既是一颗红黑树，也是一条链表【单向链表】。

下面我们通过代码来验证一下我们前面的分析：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
HashMap<String,Object> hashMap = new HashMap<>();
hashMap.put("1","1");
hashMap.put("A","A");

//获取table属性
Field tableField = HashMap.class.getDeclaredField("table");
tableField.setAccessible(true);
Object[] oArr = (Object[]) tableField.get(hashMap);
//根据我们分析的结果可以直到，发生了hash冲突，所以，其实在位置1上形成了一个链表。
System.out.println(Arrays.toString(oArr));
//再获取其内部类Node类
Class<?> aClass = Class.forName("java.util.HashMap$Node");
//拿到其Node类的next属性
Field next = aClass.getDeclaredField("next");
next.setAccessible(true);
//hash冲突发生在第一个位置上，我们取出第一个为的next。
Object o = next.get(oArr[1]);
//可以看到我们分析的没有问题
System.out.println(oArr[1]);
System.out.println(o);

结果如上图所示：

#
HashMap的putVal和resize
LinkedList 源码分析

评论

关注我

链接

分类

标签云

JavaSE Redis feign gateway hessian idea mybatis mysql nacos rabbitmq ribbon sentinel spring spring4x springboot 新冠肺炎

最新文章

归档

标签

JavaSE 9
Redis 15
feign 3
gateway 5
hessian 1
idea 1
mybatis 9
mysql 1
nacos 10
rabbitmq 1
ribbon 1
sentinel 7
spring 1
spring4x 11
springboot 14
新冠肺炎 1
Your browser is out-of-date!

Update your browser to view this website correctly. Update my browser now

×