ConcurrentHashMap是这样的吗?(学习笔记)

PS:本博客内容来源是根据Guide哥归纳的关于HashMap和ConcurrentHashMap的原理知识学习总结而来,他的JavaGuide是学习Java知识很棒的知识树,推荐大家去学习
传送门JavaGuide
本博客是笔者仅用来记录学习的,如果能够帮助到大家也是非常开心的(❁´◡`❁)

ConcurrentHashMap

  • ConcurrentHashMap是java.util.concurrent包下的线程安全集合类,对应的是解决HashMap线程不安全问题,也是并发编程常用的集合之一。

存储结构

  • Java 7中的存储结构是由很多个Segment组合,而每一个Segment是一个类似于HashMap的结构,所以每一个HashMap的内部可以进行扩容。但是Segment的个数一旦初始化就不能改变,默认Segment的个数是16个,也可以认为ConcurrentHashMap默认的支持最多16个线程并发。
  • Java8的ConcurrentHashMap相对于Java7来说变化比较大,不再是之前的Segment数组+HashEntry数组+链表,而是Node数组+链表/红黑树。当冲突链表达到一定长度时,链表会转化成红黑树。
    javaConcurrentHashMap结构

初始化

  • 通过Java7的ConcurrentHashMap的无参构造探寻ConcurrentHashMap的初始化流程。
    /**
     * Creates a new, empty map with a default initial capacity (16),
     * load factor (0.75) and concurrencyLevel (16).
     */
    public ConcurrentHashMap() {
        this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR, DEFAULT_CONCURRENCY_LEVEL);
    }
  • DEFAULT_INITIAL_CAPACITY:默认初始容量16
  • DEFAULT_LOAD_FACTOR:默认加载因子0.75f(可以通过联合HashMap的loadFactor进行认识)
  • DEFAULT_CONCURRENCY_LEVEL:默认并发级别16
    /**
     * 默认初始化容量
     */
    static final int DEFAULT_INITIAL_CAPACITY = 16;

    /**
     * 默认负载因子
     */
    static final float DEFAULT_LOAD_FACTOR = 0.75f;

    /**
     * 默认并发级别
     */
    static final int DEFAULT_CONCURRENCY_LEVEL = 16;
  • Java8则是initTable方法进行初始化操作

我们可以通过以下代码发现,ConcurrentHashMap的初始化是通过自旋和CAS操作完成的。需要注意的变量sizeCtl,它的值决定着当前的初始化状态

  1. -1表示正在初始化
  2. -N说明有N-1个线程正在进行扩容
  3. 如果table没有初始化,表示table需要初始化的大小
  4. 如果table初始化完成,表示table的容量,默认是table大小的0.75倍,用这个公式计算0.75(n-(n>>>2))。
/**
 * Initializes table, using the size recorded in sizeCtl.
 */
private final Node<K,V>[] initTable() {
    Node<K,V>[] tab; int sc;
    while ((tab = table) == null || tab.length == 0) {
        // 如果 sizeCtl < 0 ,说明另外的线程执行CAS 成功,正在进行初始化。
        if ((sc = sizeCtl) < 0)
            // 让出 CPU 使用权
            Thread.yield(); // lost initialization race; just spin
        else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
            try {
                if ((tab = table) == null || tab.length == 0) {
                    int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
                    @SuppressWarnings("unchecked")
                    Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
                    table = tab = nt;
                    sc = n - (n >>> 2);
                }
            } finally {
                sizeCtl = sc;
            }
            break;
        }
    }
    return tab;
}
  • Java7的ConcurrentHashMap的有参构造函数
@SuppressWarnings("unchecked")
public ConcurrentHashMap(int initialCapacity,float loadFactor, int concurrencyLevel) {
    // 参数校验
    if (!(loadFactor > 0) || initialCapacity < 0 || concurrencyLevel <= 0)
        throw new IllegalArgumentException();
    // 校验并发级别大小,大于 1<<16,重置为 65536
    if (concurrencyLevel > MAX_SEGMENTS)
        concurrencyLevel = MAX_SEGMENTS;
    // Find power-of-two sizes best matching arguments
    // 2的多少次方
    int sshift = 0;
    int ssize = 1;
    // 这个循环可以找到 concurrencyLevel 之上最近的 2的次方值
    while (ssize < concurrencyLevel) {
        ++sshift;
        ssize <<= 1;
    }
    // 记录段偏移量
    this.segmentShift = 32 - sshift;
    // 记录段掩码
    this.segmentMask = ssize - 1;
    // 设置容量
    if (initialCapacity > MAXIMUM_CAPACITY)
        initialCapacity = MAXIMUM_CAPACITY;
    // c = 容量 / ssize ,默认 16 / 16 = 1,这里是计算每个 Segment 中的类似于 HashMap 的容量
    int c = initialCapacity / ssize;
    if (c * ssize < initialCapacity)
        ++c;
    int cap = MIN_SEGMENT_TABLE_CAPACITY;
    //Segment 中的类似于 HashMap 的容量至少是2或者2的倍数
    while (cap < c)
        cap <<= 1;
    // create segments and segments[0]
    // 创建 Segment 数组,设置 segments[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); // ordered write of segments[0]
    this.segments = ss;
}
  • Java7中ConcurrentHashMap的初始化逻辑:
  1. 必要的参数检验
  2. 校验并发级别concurrentcyLevel大小,如果大于最大值,重置最大值。无参构造默认值是16
  3. 寻找并发级别concurrencyLevel之上最近的2的幂次方值,作为初始化容量大小,默认是16
  4. 记录segmentShift偏移量,这个值为【容量=2的N次方】中的N,在后面put时计算位置时会用到。默认是32 - sshift = 28
  5. 记录segmentMash,默认是ssize - 1 = 16 -1 = 15.
  6. 初始化segments[0],默认大小为2负载因子为0.75扩容阀值是2*0.75=1.5,插入第二个值时才会进行扩容。

put方法

  • Java7ConcurrentHashMap在put一个数据的流程如下:
  1. 计算要put的key的位置,获取指定位置的Segment。
  2. 如果指定位置的Segment为空,则初始化这个Segment。

初始化Segment的流程:

  1. 检查计算所得到的位置的Segment是否为null
  2. 为null继续初始化,使用Segment[0]的容量和负载因子创建一个HashEntry数组
  3. 再次检查计算得到的指定位置的Segment是否为mull
  4. 使用创建HashEntry数组初始化这个Segment
  5. 自旋判断计算得到的指定位置的Segment是否为null,使用CAS在这个位置复制为Segment
  1. Segment.put插入Key,value值:

Segment继承了ReenTratLock,所以Segment内部可以跟方便的获取锁,put流程就用到了这个功能。

  1. tryLock()获取锁,获取不到使用scanAndLockForPut方法继续获取,其实就是通过不停的自旋tryLock获取锁,当自选次数大于指定次数时,则会阻塞直到获取到锁。
  2. 计算put的数据要放入的index位置,然后获取这个位置上的HashEntry。
  3. 遍历put新元素,为什么要遍历?因为这里获取的HashEntry可能是一个空元素,也可能是链表已存在,所以要区别对待
    (1)如果这个位置上的HashEntry不存在:如果当前容量大于扩容阀值,小于最大容量,进行扩容;使用头插法插入
    (2)如果存在:判断链表当前元素key和hash值是否要put的key和hash值一致,一致则替换;反之则获取链表下一节点,直到发现相同进行值替换,或者没有相同的则如(1)操作;
  4. 如果插入的位置之前已经存在,替换后返回旧值,否则返回null。
  • Java8的put方法流程:
  1. 根据key计算出hashcode
    2.判断是否需要进行初始化
  2. 即为当前key定位出的Node,如果为空表示当前位置可以写入数据,利用CAS尝试写入,失效则自旋保证成功
  3. 如果当前位置的hashcode == MOVED == -1,则需要进行扩容
  4. 如果都不满足,则利用synchronized锁写入数据。
  5. 如果数量大于TREEIFY_THRESHOLD则要转化红黑树

总结

ConcurrentHashMap的背景是线程不安全的HashMap和效率低下的HashTable,Java7中使用的是分段锁,也就是每个Segment都是一个类似HashMap数组的结构,可扩容,发生冲突会转化成链表,但Segment的个数一旦初始化就不能改变,数据结构是Segment数组+HashEntry数组+链表,而Java8开始则是使用Synchronized锁加CAS的机制,Node是类似于一个HashEntry的结构,发生冲突达到一定大小时会转化成红黑树,在冲突小于一定数量时又退回链表,数据结构是Node数组+链表/红黑树

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

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值