前往小程序,Get更优阅读体验!
立即前往
首页
学习
活动
专区
工具
TVP
发布
社区首页 >专栏 >ConcurrentHashMap(JDK8)

ConcurrentHashMap(JDK8)

作者头像
chenchenchen
发布2021-09-06 14:20:16
13.9K1
发布2021-09-06 14:20:16
举报
文章被收录于专栏:chenchenchen

对比

与HashMap的区别是什么?

ConcurrentHashMap是HashMap的升级版,HashMap是线程不安全的,而ConcurrentHashMap是线程安全。而其他功能和实现原理和HashMap类似。

与Hashtable的区别是什么?

Hashtable也是线程安全的,但每次要锁住整个结构,并发性低。相比之下,ConcurrentHashMap获取size时才锁整个对象。

Hashtable对get/put/remove都使用了同步操作。ConcurrentHashMap只对put/remove同步。

Hashtable是快速失败的,遍历时改变结构会报错ConcurrentModificationException。ConcurrentHashMap是安全失败,允许并发检索和更新。

JDK8的ConcurrentHashMap和JDK7的ConcurrentHashMap有什么区别?

  1. JDK8中新增了红黑树
  2. JDK7中使用的是头插法,JDK8中使用的是尾插法
  3. JDK7中使用了分段锁,而JDK8中没有使用分段锁了
  4. JDK7中使用了ReentrantLock,JDK8中没有使用ReentrantLock了,而使用了Synchronized
  5. JDK7中的扩容是每个Segment内部进行扩容,不会影响其他Segment,而JDK8中的扩容和HashMap的扩容类似,只不过支持了多线程扩容,并且保证了线程安全

特性

ConcurrentHashMap是如何保证并发安全的?

JDK7中ConcurrentHashMap是通过ReentrantLock+CAS+分段思想来保证的并发安全的,ConcurrentHashMap的put方法会通过CAS的方式,把一个Segment对象存到Segment数组中,一个Segment内部存在一个HashEntry数组,相当于分段的HashMap,Segment继承了ReentrantLock,每段put开始会加锁。

在JDK7的ConcurrentHashMap中,首先有一个Segment数组,存的是Segment对象,Segment相当于一个小HashMap,Segment内部有一个HashEntry的数组,也有扩容的阈值,同时Segment继承了ReentrantLock类,同时在Segment中还提供了put,get等方法,比如Segment的put方法在一开始就会去加锁,加到锁之后才会把key,value存到Segment中去,然后释放锁。同时在ConcurrentHashMap的put方法中,会通过CAS的方式把一个Segment对象存到Segment数组的某个位置中。同时因为一个Segment内部存在一个HashEntry数组,所以和HashMap对比来看,相当于分段了,每段里面是一个小的HashMap,每段公用一把锁,同时在ConcurrentHashMap的构造方法中是可以设置分段的数量的,叫做并发级别concurrencyLevel.

JDK8中ConcurrentHashMap是通过synchronized+cas来实现了。在JDK8中只有一个数组,就是Node数组,Node就是key,value,hashcode封装出来的对象,和HashMap中的Entry一样,在JDK8中通过对Node数组的某个index位置的元素进行同步,达到该index位置的并发安全。同时内部也利用了CAS对数组的某个位置进行并发安全的赋值。

JDK8中的ConcurrentHashMap为什么使用synchronized来进行加锁?

JDK8中使用synchronized加锁时,是对链表头结点和红黑树根结点来加锁的,而ConcurrentHashMap会保证,数组中某个位置的元素一定是链表的头结点或红黑树的根结点,所以JDK8中的ConcurrentHashMap在对某个桶进行并发安全控制时,只需要使用synchronized对当前那个位置的数组上的元素进行加锁即可,对于每个桶,只有获取到了第一个元素上的锁,才能操作这个桶,不管这个桶是一个链表还是红黑树。

想比于JDK7中使用ReentrantLock来加锁,因为JDK7中使用了分段锁,所以对于一个ConcurrentHashMap对象而言,分了几段就得有几个ReentrantLock对象,表示得有对应的几把锁。

而JDK8中使用synchronized关键字来加锁就会更节省内存,并且jdk也已经对synchronized的底层工作机制进行了优化,效率更好。

JDK7中的ConcurrentHashMap是如何扩容的?

JDK7中的ConcurrentHashMap和JDK7的HashMap的扩容是不太一样的,首先JDK7中也是支持多线程扩容的,原因是,JDK7中的ConcurrentHashMap分段了,每一段叫做Segment对象,每个Segment对象相当于一个HashMap,分段之后,对于ConcurrentHashMap而言,能同时支持多个线程进行操作,前提是这些操作的是不同的Segment,而ConcurrentHashMap中的扩容是仅限于本Segment,也就是对应的小型HashMap进行扩容,所以是可以多线程扩容的。

每个Segment内部的扩容逻辑和HashMap中一样。

JDK8中的ConcurrentHashMap是如何扩容的?

首先,JDK8中是支持多线程扩容的,JDK8中的ConcurrentHashMap不再是分段,或者可以理解为每个桶为一段,在需要扩容时,首先会生成一个双倍大小的数组,生成完数组后,线程就会开始转移元素,在扩容的过程中,如果有其他线程在put,那么这个put线程会帮助去进行元素的转移,虽然叫转移,但是其实是基于原数组上的Node信息去生成一个新的Node的,也就是原数组上的Node不会消失,因为在扩容的过程中,如果有其他线程在get也是可以的。

JDK8中的ConcurrentHashMap有一个CounterCell,你是如何理解的?

CounterCell是JDK8中用来统计ConcurrentHashMap中所有元素个数的,在统计ConcurentHashMap时,不能直接对ConcurrentHashMap对象进行加锁然后再去统计,因为这样会影响ConcurrentHashMap的put等操作的效率,在JDK8的实现中使用了CounterCell+baseCount来辅助进行统计,baseCount是ConcurrentHashMap中的一个属性,某个线程在调用ConcurrentHashMap对象的put操作时,会先通过CAS去修改baseCount的值,如果CAS修改成功,就计数成功,如果CAS修改失败,则会从CounterCell数组中随机选出一个CounterCell对象,然后利用CAS去修改CounterCell对象中的值,因为存在CounterCell数组,所以,当某个线程想要计数时,先尝试通过CAS去修改baseCount的值,如果没有修改成功,则从CounterCell数组中随机取出来一个CounterCell对象进行CAS计数,这样在计数时提高了效率。

所以ConcurrentHashMap在统计元素个数时,就是baseCount加上所有CountCeller中的value值,所得的和就是所有的元素个数。

使用场景

多用户同时登入和登出

代码语言:javascript
复制
// 在线用户管理类
public class UserManager {
    private Map<String, User> userMap = new ConcurrentHashMap<>();
    
    // 当用户登入时调用
    public void onUserSignIn(String sessionId, User user) {
        this.userMap.put(sessionId, user);
    }
    
    // 当用户登出或超时时调用
    public void onUserSignOut(String sessionId) {
        this.userMap.remove(sessionId);
    }
    
    public getUser(String sessionId) {
        return this.userMap.get(sessionId);
    }
}

统计文本单词

多线程统计文本单词,下面代码会出现BUG

代码语言:javascript
复制
ConcurrentHashMap map  = new ConcurrentHashMap<String,Integer>();
​
//下面多线程运行,会出现BUG
Integer value= map.get(word);
if (value==null){
    map.put(word,1);
}else {
    map.put(word,value++);
}computeIfAbsent

ConcurrentHashMap可以保证单个get/put操作的原子性,但是不能保证两个一起就是原子性。

如何解决? ConcurrentHashMap提供了两个方法

  • computeIfAbsent:计算如果不存在。如果key不存在,存入计算结果并返回
  • computeIfPresent:计算如果存在。如果key存在,计算公式并返回
代码语言:javascript
复制
ConcurrentHashMap<String,Integer> map  = new ConcurrentHashMap<>();
Integer a1 = map.computeIfAbsent("a", (key) -> 1+1);
Integer a2 = map.computeIfPresent("a", (key,value) -> map.get(key)+value);
System.out.println(a1);// 2
System.out.println(a2);// 4

将Integer替换为原子类LongAdder,解决多线程a++问题即可。

存储线程资源池,为每种请求类型创建一个线程池

初始化一个成员变量map。当请求到达时,检查map中是否已经存在创建好的线程池即可,如果存在则返回,如果不存在就创建一个新的线程池放入map中,同时返回新创建的线程池。

代码语言:javascript
复制
public ThreadPool getThreadPool(String type) {
​
    RingBuffer<StringEvent> disruptor = threadPoolMap.get(type);
    if (disruptor == null) {
        synchronized (this) {
            disruptor = threadPoolMap.get(type);
            if (disruptor == null) {
                threadPoolMap.put(type, createThreadPool(type));
            }
        }
    }
    return threadPoolMap.get(type);
​
}

使用ConcurrentHashMap的性能会比单纯的使用synchronized+hashMap高很多。

代码语言:javascript
复制
   public ThreadPool getThreadPool(String type) {
​
    RingBuffer<StringEvent> disruptor = threadPoolMap.get(type);
    if (disruptor == null) {
        threadPoolMap.computeIfAbsent(type, (key) -> createThreadPool(type));
       }
    }
    return threadPoolMap.get(type);

读超过写,作为缓存

CHM适用于做cache,在程序启动时初始化,之后可以被多个请求线程访问。

  • 当写者数量大于等于读者时,CHM的性能是低于Hashtable和synchronized Map的。
  • 因为当锁住了整个Map时,读操作要等待对同一部分执行写操作的线程结束。
  • CHM是HashTable一个很好的替代,但CHM的比HashTable的同步性稍弱。

获取操作get与更新操作交迭(包括 put 和 remove)

遍历过程中,集合结构变化,不会抛出ConcurrentModificationException,能够正常遍历完成。

原因:

1、读写不互斥,其他线程修改容器中部分副本时,读操作不受影响。

2、hapend-before机制,避免读取到更新前的数据。

3、读写机制通过violatile实现,迭代时、数组扩容时保证数据的可见性,不会出现数组越界等异常。

源码解析:

参考:

关于jdk1.8中ConcurrentHashMap的方方面面:https://blog.csdn.net/tp7309/article/details/76532366

ConcurrentHashMap源码分析(JDK1.8):https://blog.csdn.net/ji1162765575/article/details/111309612

ConcurrentHashMap为何不会出现ConcurrentModificationException异常:https://www.bbsmax.com/A/6pdDgqbq5w/

concurrentHashMap对concurrentModificationException的处理:https://www.jianshu.com/p/0b769a8779f6

ConcurrentHashMap源码分析(JDK8) get/put/remove方法分析:https://www.jianshu.com/p/5bc70d9e5410

ConcurrentHashMap的错误使用:https://zhuanlan.zhihu.com/p/113379816

什么时候使用ConcurrentHashMap:https://my.oschina.net/u/3847203/blog/3084619

ConcurrentHashMap的使用场景:https://blog.csdn.net/a_fengzi_code_110/article/details/61191591

本文参与 腾讯云自媒体同步曝光计划,分享自作者个人站点/博客。
原始发表:2021/04/05 ,如有侵权请联系 cloudcommunity@tencent.com 删除

本文分享自 作者个人站点/博客 前往查看

如有侵权,请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体同步曝光计划  ,欢迎热爱写作的你一起参与!

评论
登录后参与评论
0 条评论
热度
最新
推荐阅读
目录
  • 对比
    • 与HashMap的区别是什么?
      • 与Hashtable的区别是什么?
        • JDK8的ConcurrentHashMap和JDK7的ConcurrentHashMap有什么区别?
        • 特性
          • ConcurrentHashMap是如何保证并发安全的?
            • JDK8中的ConcurrentHashMap为什么使用synchronized来进行加锁?
              • JDK7中的ConcurrentHashMap是如何扩容的?
                • JDK8中的ConcurrentHashMap是如何扩容的?
                  • JDK8中的ConcurrentHashMap有一个CounterCell,你是如何理解的?
                    • 多用户同时登入和登出
                    • 统计文本单词
                    • 存储线程资源池,为每种请求类型创建一个线程池
                    • 读超过写,作为缓存
                    • 获取操作get与更新操作交迭(包括 put 和 remove)
                • 使用场景
                相关产品与服务
                容器服务
                腾讯云容器服务(Tencent Kubernetes Engine, TKE)基于原生 kubernetes 提供以容器为核心的、高度可扩展的高性能容器管理服务,覆盖 Serverless、边缘计算、分布式云等多种业务部署场景,业内首创单个集群兼容多种计算节点的容器资源管理模式。同时产品作为云原生 Finops 领先布道者,主导开源项目Crane,全面助力客户实现资源优化、成本控制。
                领券
                问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档