ConcurrentHashMap（JDK8）

chenchenchen

发布于 2021-09-06 14:20:16

13.8K1

发布于 2021-09-06 14:20:16

文章被收录于专栏：chenchenchenchenchenchen

对比

与HashMap的区别是什么？

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

与Hashtable的区别是什么？

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

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

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

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

JDK8中新增了红黑树
JDK7中使用的是头插法，JDK8中使用的是尾插法
JDK7中使用了分段锁，而JDK8中没有使用分段锁了
JDK7中使用了ReentrantLock，JDK8中没有使用ReentrantLock了，而使用了Synchronized
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值，所得的和就是所有的元素个数。

使用场景

多用户同时登入和登出

// 在线用户管理类
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

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存在，计算公式并返回

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中，同时返回新创建的线程池。

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高很多。

   public ThreadPool getThreadPool(String type) {

    RingBuffer<StringEvent> disruptor = threadPoolMap.get(type);
    if (disruptor == null) {
        threadPoolMap.computeIfAbsent(type, (key) -> createThreadPool(type));
       }
    }
    return threadPoolMap.get(type);