【并发编程】JDK1.7 HashMap的原理和实现

一、Java1.7 HashMap死循环分析

Java1.7 HashMap导致死循环的主要原因是扩容后,节点的顺序会反掉(头插法),多线程环境下可能会出现环形链表。

Java1.8 HashMap(尾插法)不会再出现死循环的问题。

环形链表的出现

 

二、 ConcurrentHashMap中的数据结构

ConcurrentHashMap是由Segment数组结构(分段锁)和HashEntry数组结构(锁住hashentry数组)组成。Segment实际继承自可重入锁(ReentrantLock),在ConcurrentHashMap里扮演锁的角色;HashEntry则用于存储键值对数据。一个ConcurrentHashMap里包含一个分段锁Segment数组,每个Segment里包含一个HashEntry数组,我们称之为table,每个HashEntry是一个链表结构的元素。

 

面试常问:

  1. ConcurrentHashMap实现原理是怎么样的或者问ConcurrentHashMap如何在保证高并发下线程安全的同时实现了性能提升?

答:ConcurrentHashMap允许多个修改操作并发进行,其关键在于使用了锁分离技术。它使用了多个锁来控制对hash表的不同部分进行的修改。内部使用段(Segment)来表示这些不同的部分,每个段其实就是一个小的hash table,只要多个修改操作发生在不同的段上,它们就可以并发进行。

三、初始化做了什么事?

初始化有三个参数

initialCapacity:初始容量大小 ,默认16

loadFactor, 扩容因子,默认0.75,当一个Segment存储的元素数量大于initialCapacity* loadFactor时,该Segment会进行一次扩容。

concurrencyLevel 并发度,默认16。并发度可以理解为程序运行时能够同时更新ConccurentHashMap且不产生锁竞争的最大线程数,实际上就是ConcurrentHashMap中的分段锁个数,即Segment[]的数组长度。如果并发度设置的过小,会带来严重的锁竞争问题;

如果并发度设置的过小,那么hash散列冲突率会增多,重排概率增加;

如果并发度设置的过大,原本位于同一个Segment内的访问会扩散到不同的Segment中,CPU cache命中率会下降,从而引起程序性能下降。

四、源码解读

1. Segment数组的大小,一定为2的幂

while(ssize < concurrencyLevel) {
    ++sshift;
    ssize <<= 1;
}

为了保证Segment数组的大小,一定为2的幂(1.快速定位(二分法)、2.减少数据迁移量),例如用户设置并发度为17,则实际Segment数组大小则为32。

2. 每个Segment中tabel数组的大小,一定为2的幂

int cap = MIN_SEGMENT_TABLE_CAPACITY;
while (cap < c) 
    cap <<= 1;

保证每个Segment中tabel数组的大小,一定为2的幂,初始化的三个参数取默认值时,table数组大小为2。

3. 初始化Segment数组,并实际只填充Segment数组的第0个元素

Segment<K,V> s0 = new Segment<K,V>(loadFactor, (int)(cap * loadFactor),
                                   (HashEntry<K,V>[])new HashEntry[cap]);
Segment<K,V>[] ss = (Segment<K,V>[])new Segment[ssize];
UNSAFE.putOrderedObject(ss, SBASE, s0);
this.segments = ss;

4. Segment偏移位数

this.segmnetShift = 32 - sshift;
this.segmentMask = ssize - 1;

用于定位元素所在segment,segmentShift表示偏移位数,通过前面的int类型的位的描述我们可以得知,int类型的数字在变大的过程中,低位总是比高位先填满的,为保证元素在segment级别分布的尽量均匀,计算元素所在segment时,总是取hash值的高位进行计算。segmentMask作用就是为了利用位运算中取模的操作: a % (Math.pow(2,n)) 等价于 a&( Math.pow(2,n)-1)。

5. get和put是如何快速定位元素的位置的?

对于某个元素而言,一定是放在某个segment元素的某个table元素中的,所以在定位上,

(1)定位segment:取得key的hashcode值进行一次再散列,拿到再散列值后,以再散列值的高位进行取模得到当前元素在哪个segment上。

(2)定位table:同样是取得key的再散列值以后,用再散列值的全部和table的长度进行取模,得到当前元素在table的哪个元素上。

6. get()

定位segment和定位table后,依次扫描这个table元素下的的链表,要么找到元素,要么返回null。

问:在高并发下的情况下如何保证取得的元素是最新的?

答:用于存储键值对数据的HashEntry,在设计上它的成员变量value等都是volatile类型的,这样就保证别的线程对value值的修改,get方法可以马上看到。

    public V get(Object key) {
        Node<K,V> e;
        return (e = getNode(hash(key), key)) == null ? null : e.value;
    }

7. put()

(1)首先定位segment,当这个segment在map初始化后,还为null,由ensureSegment方法负责填充这个segment。

 循环拿锁+阻塞性拿锁

(2)对Segment 加锁

final V put(K key, int hash, V value, boolean onlyIfAbsent) {
    HashEntry<K,V> node = tryLock() ? null : scanAndLockForPut(key, hash, value);
    V oldValue;
    // ...
}

8. size()

size的时候进行两次不加锁的统计,两次一致直接返回结果,不一致,重新加锁再次统计。

五、扩容操作

Segment 不扩容,扩容下面的table数组,每次都是将原数组翻倍。

HashEntry<K,V>[] oldTable = table;
int oldCapacity = oldTable.length;
int newCapacity = oldCapacity << 1;
threshold = (int) (newCapacity * loadFactor);

带来的好处

假设原来table长度为4,那么元素在table中的分布是这样的:

Hash值

15

23

34

56

77

在table中下标

3  = 15%4

3 = 23 % 4

2 = 34%4

0 = 56%4

1 = 77 % 4

扩容后table长度变为8,那么元素在table中的分布变成:

Hash值

56

34

77

15,23

下标

0

1

2

3

4

5

6

7

可以看见 hash值为34和56的下标保持不变,而15,23,77的下标都是在原来下标的基础上+4即可,可以快速定位和减少重排次数

六、弱一致性

get方法和containsKey方法都是通过对链表遍历判断是否存在key相同的节点以及获得该节点的value。但由于遍历过程中其他线程可能对链表结构做了调整,因此get和containsKey返回的可能是过时的数据,这一点是ConcurrentHashMap在弱一致性上的体现。

  • 3
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 4
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值