HashMap与ConcurrentHashMap要点

HashMap

HashMap底层数据结构

JDK=中的HashMap为什么要使⽤红⿊树？

JDK=中的HashMap什么时候将链表转化为红⿊树？

JDK=中HashMap的put⽅法的实现过程？

JDK=中HashMap的get⽅法的实现过程

JDK<与JDK=中HashMap的不同点

ConcurrentHashMap

JDK<中的ConcurrentHashMap是怎么保证并发安全的？

JDK<中的ConcurrentHashMap的底层原理

JDK=中的ConcurrentHashMap是怎么保证并发安全的？

JDK<和JDK=中的ConcurrentHashMap的不同点

HashMap

HashMap底层数据结构

JDK7：数组+链表

JDK8: 数组+链表+红⿊树（看过源码的同学应该知道JDK8中即使⽤了单向链表，也使⽤了双向链表，双

向链表主要是为了链表操作⽅便，应该在插⼊，扩容，链表转红⿊树，红⿊树转链表的过程中都要操作链

表）

JDK8中的HashMap为什么要使⽤红⿊树？

当元素个数⼩于⼀个阈值时，链表整体的插⼊查询效率要⾼于红⿊树，当元素个数⼤于此阈值时，链表整

体的插⼊查询效率要低于红⿊树。此阈值在HashMap中为8

JDK8中的HashMap什么时候将链表转化为红⿊树？

这个题很容易答错，⼤部分答案就是：当链表中的元素个数⼤于8时就会把链表转化为红⿊树。但是其实还

有另外⼀个限制：当发现链表中的元素个数⼤于8之后，还会判断⼀下当前数组的⻓度，如果数组⻓度⼩于

1 64时，此时并不会转化为红⿊树，⽽是进⾏扩容。只有当链表中的元素个数⼤于8，并且 数组的⻓度⼤于

等于64 时才会将链表转为红⿊树。

上⾯扩容的原因是，如果数组⻓度还⽐较⼩，就先利⽤扩容来缩⼩链表的⻓度。

JDK8中HashMap的put⽅法的实现过程？

1. 根据key⽣成hashcode

2. 判断当前HashMap对象中的数组是否为空，如果为空则初始化该数组

3. 根据逻辑与运算，算出hashcode基于当前数组对应的数组下标i

4. 判断数组的第i个位置的元素（tab[i]）是否为空

a. 如果为空，则将key，value封装为Node对象赋值给tab[i]

b. 如果不为空：

i. 如果put⽅法传⼊进来的key等于tab[i].key，那么证明存在相同的key

ii. 如果不等于tab[i].key，则：

1. 如果tab[i]的类型是TreeNode，则表示数组的第i位置上是⼀颗红⿊树，那么将key和

value插⼊到红⿊树中，并且在插⼊之前会判断在红⿊树中是否存在相同的key

2. 如果tab[i]的类型不是TreeNode，则表示数组的第i位置上是⼀个链表，那么遍历链表寻

找是否存在相同的key，并且在遍历的过程中会对链表中的结点数进⾏计数，当遍历到最

后⼀个结点时，会将key,value封装为Node插⼊到链表的尾部，同时判断在插⼊新结点之

前的链表结点个数是不是⼤于等于8，如果是，则将链表改为红⿊树。

iii. 如果上述步骤中发现存在相同的key，则根据onlyIfAbsent标记来判断是否需要更新value值，

然后返回oldValue

5. modCount++

6. HashMap的元素个数size加1

7. 如果size⼤于扩容的阈值，则进⾏扩容

JDK8中HashMap的get⽅法的实现过程

1. 根据key⽣成hashcode

2. 如果数组为空，则直接返回空

3. 如果数组不为空，则利⽤hashcode和数组⻓度通过逻辑与操作算出key所对应的数组下标i

4. 如果数组的第i个位置上没有元素，则直接返回空

5. 如果数组的第1个位上的元素的key等于get⽅法所传进来的key，则返回该元素，并获取该元素的value

6. 如果不等于则判断该元素还有没有下⼀个元素，如果没有，返回空

7. 如果有则判断该元素的类型是链表结点还是红⿊树结点

a. 如果是链表则遍历链表

b. 如果是红⿊树则遍历红⿊树

8. 找到即返回元素，没找到的则返回空

2JDK7与JDK8中HashMap的不同点

1. JDK8中使⽤了红⿊树

2. JDK7中链表的插⼊使⽤的头插法（扩容转移元素的时候也是使⽤的头插法，头插法速度更快，⽆需遍

历链表，但是在多线程扩容的情况下使⽤头插法会出现循环链表的问题，导致CPU飙升），JDK8中链

表使⽤的尾插法（JDK8中反正要去计算链表当前结点的个数，反正要遍历的链表的，所以直接使⽤尾

插法）

3. JDK7的Hash算法⽐JDK8中的更复杂，Hash算法越复杂，⽣成的hashcode则更散列，那么hashmap

中的元素则更散列，更散列则hashmap的查询性能更好，JDK7中没有红⿊树，所以只能优化Hash算

法使得元素更散列，⽽JDK8中增加了红⿊树，查询性能得到了保障，所以可以简化⼀下Hash算法，毕

竟Hash算法越复杂就越消耗CPU

4. 扩容的过程中JDK7中有可能会重新对key进⾏哈希（重新Hash跟哈希种⼦有关系），⽽JDK8中没有这

部分逻辑

5. JDK8中扩容的条件和JDK7中不⼀样，除开判断size是否⼤于阈值之外，JDK7中还判断了tab[i]是否为

空，不为空的时候才会进⾏扩容，⽽JDK8中则没有该条件了

6. JDK8中还多了⼀个API：putIfAbsent(key,value)

7. JDK7和JDK8扩容过程中转移元素的逻辑不⼀样，JDK7是每次转移⼀个元素，JDK8是先算出来当前位

置上哪些元素在新数组的低位上，哪些在新数组的⾼位上，然后在⼀次性转移

ConcurrentHashMap

JDK7中的ConcurrentHashMap是怎么保证并发安全的？

主要利⽤Unsafe操作+ReentrantLock+分段思想。

主要使⽤了Unsafe操作中的：

1. compareAndSwapObject：通过cas的⽅式修改对象的属性

2. putOrderedObject：并发安全的给数组的某个位置赋值

3. getObjectVolatile：并发安全的获取数组某个位置的元素

分段思想是为了提⾼ConcurrentHashMap的并发量，分段数越⾼则⽀持的最⼤并发量越⾼，程序员可以

通过concurrencyLevel参数来指定并发量。ConcurrentHashMap的内部类Segment就是⽤来表示某⼀个

段的。

每个Segment就是⼀个⼩型的HashMap的，当调⽤ConcurrentHashMap的put⽅法是，最终会调⽤到

Segment的put⽅法，⽽Segment类继承了ReentrantLock，所以Segment⾃带可重⼊锁，当调⽤到

Segment的put⽅法时，会先利⽤可重⼊锁加锁，加锁成功后再将待插⼊的key,value插⼊到⼩型HashMap

中，插⼊完成后解锁。

JDK7中的ConcurrentHashMap的底层原理

3 ConcurrentHashMap底层是由两层嵌套数组来实现的：

1. ConcurrentHashMap对象中有⼀个属性segments，类型为Segment[];

2. Segment对象中有⼀个属性table，类型为HashEntry[];

当调⽤ConcurrentHashMap的put⽅法时，先根据key计算出对应的Segment[]的数组下标j，确定好当前

key,value应该插⼊到哪个Segment对象中，如果segments[j]为空，则利⽤⾃旋锁的⽅式在j位置⽣成⼀个

Segment对象。

然后调⽤Segment对象的put⽅法。

Segment对象的put⽅法会先加锁，然后也根据key计算出对应的HashEntry[]的数组下标i，然后将

key,value封装为HashEntry对象放⼊该位置，此过程和JDK7的HashMap的put⽅法⼀样，然后解锁。

在加锁的过程中逻辑⽐较复杂，先通过⾃旋加锁，如果超过⼀定次数就会直接阻塞等等加锁。（具体流程

请求看vip视频.）

JDK8中的ConcurrentHashMap是怎么保证并发安全的？

主要利⽤Unsafe操作+synchronized关键字。

Unsafe操作的使⽤仍然和JDK7中的类似，主要负责并发安全的修改对象的属性或数组某个位置的值。

synchronized主要负责在需要操作某个位置时进⾏加锁（该位置不为空），⽐如向某个位置的链表进⾏插

⼊结点，向某个位置的红⿊树插⼊结点。

JDK8中其实仍然有分段锁的思想，只不过JDK7中段数是可以控制的，⽽JDK8中是数组的每⼀个位置都有

⼀把锁。

当向ConcurrentHashMap中put⼀个key,value时，

1. ⾸先根据key计算对应的数组下标i，如果该位置没有元素，则通过⾃旋的⽅法去向该位置赋值。

2. 如果该位置有元素，则synchronized会加锁

3. 加锁成功之后，在判断该元素的类型

a. 如果是链表节点则进⾏添加节点到链表中

b. 如果是红⿊树则添加节点到红⿊树

4. 添加成功后，判断是否需要进⾏树化

5. addCount，这个⽅法的意思是ConcurrentHashMap的元素个数加1，但是这个操作也是需要并发安全

的，并且元素个数加1成功后，会继续判断是否要进⾏扩容，如果需要，则会进⾏扩容，所以这个⽅法

很重要。

6. 同时⼀个线程在put时如果发现当前ConcurrentHashMap正在进⾏扩容则会去帮助扩容。

 

JDK7和JDK8中的ConcurrentHashMap的不同点

这两个的不同点太多了...，既包括了HashMap中的不同点，也有其他不同点，⽐如：

1. JDK8中没有分段锁了，⽽是使⽤synchronized来进⾏控制

2. JDK8中的扩容性能更⾼，⽀持多线程同时扩容，实际上JDK7中也⽀持多线程扩容，因为JDK7中的扩

容是针对每个Segment的，所以也可能多线程扩容，但是性能没有JDK8⾼，因为JDK8中对于任意⼀

个线程都可以去帮助扩容

3. JDK8中的元素个数统计的实现也不⼀样了，JDK8中增加了CounterCell来帮助计数，⽽JDK7中没

有，JDK7中是put的时候每个Segment内部计数，统计的时候是遍历每个Segment对象加锁统计