(十二) ConcurrentHashMap分段锁设计原理

最新推荐文章于 2024-04-26 06:37:27 发布
最新推荐文章于 2024-04-26 06:37:27 发布
阅读量907 收藏
点赞数
分类专栏： 并发编程 文章标签： 并发编程 java.util.concurrent java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/q331464542/article/details/120496757
版权

内容目录

分段锁设计提高统计元素数量的性能

最后一个部分，也是ConcurrentHashMap中设计比较巧妙的地方。我们知道，当调用完put方法后，ConcurrentHashMap必须会增加当前元素的个数，方便在size()方法中获得存储的数据大小。代码的实现如下。

final V putVal(K key, V value, boolean onlyIfAbsent) {
    //省略部分代码....
    addCount(1L, binCount);
    return null;
}

很多读者可能会问，这块代码有什么好值得分析的呢？请大家思考一个问题，在常规的集合中，我们只需要一个全局int类型的字段去保存元素个数即可，每次添加一个元素，就对这个size变量+1。但是在ConcurrentHashMap集合中，需要保证对于该变量修改的线程安全性，那怎么设计呢？难道又用锁来实现？很显然，通过前面的分析，使用同步锁带来的性能开销太大，所以不适合。因此，在ConcurrentHashMap中，采用的是自旋锁和分段锁的设计。

size计数的基本原理分析

在ConcurrentHashMap中，采用两种方式来保存元素的个数。

  • 当线程竞争不激烈时，直接对baseCount+1来增加元素个数。
  • 当线程竞争比较激烈时，通过构建一个CounterCell数组，默认长度是2，然后通过随机算法选择一个CounterCell，针对该CounterCell中的value进行保存。
private transient volatile long baseCount;
private transient volatile CounterCell[] counterCells;

元素个数累加的整体流程如下图所示。

在这里插入图片描述

addCount方法分析

addCount方法的完整代码如下，从整体结构来看，包含两个部分的逻辑。

  • 对ConcurrentHashMap中元素个数进行累加。
  • 通过check>=0来判断是否需要扩容，这部分代码在前面分析tranfer()方法中有讲过，就不再赘述。
private final void addCount(long x, int check) {
    CounterCell[] as; long b, s;
    if ((as = counterCells) != null ||
        !U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) {
        CounterCell a; long v; int m;
        boolean uncontended = true;
        if (as == null || (m = as.length - 1) < 0 ||
            (a = as[ThreadLocalRandom.getProbe() & m]) == null ||
            !(uncontended =
              U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))) {
            fullAddCount(x, uncontended);
            return;
        }
        if (check <= 1)
            return;
        s = sumCount();
    }
    if (check >= 0) {
        Node<K,V>[] tab, nt; int n, sc;
        while (s >= (long)(sc = sizeCtl) && (tab = table) != null &&
               (n = tab.length) < MAXIMUM_CAPACITY) {
            int rs = resizeStamp(n);
            if (sc < 0) {
                if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
                    sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
                    transferIndex <= 0)
                    break;
                if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
                    transfer(tab, nt);
            }
            else if (U.compareAndSwapInt(this, SIZECTL, sc,
                                         (rs << RESIZE_STAMP_SHIFT) + 2))
                transfer(tab, null);
            s = sumCount();
        }
    }
}

我们重点来分析下面这段增加元素个数的代码。

private final void addCount(long x, int check) {
    CounterCell[] as; long b, s;
    if ((as = counterCells) != null ||
        !U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) {
        CounterCell a; long v; int m;
        boolean uncontended = true;
        if (as == null || (m = as.length - 1) < 0 ||
            (a = as[ThreadLocalRandom.getProbe() & m]) == null ||
            !(uncontended =
              U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))) {
            fullAddCount(x, uncontended);
            return;
        }
        if (check <= 1)
            return;
        s = sumCount();
    }
}

上述代码的处理逻辑如下：

  • 在if判断中，第一步就是先通过U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)修改全局成员变量baseCount进行累加。这个方法在线程竞争的情况下会返回false。
  • 如果第一步执行失败，则尝试使用CounterCell进行累加，这里面有几个逻辑。
    • 在if判断中通过as=counterCells把当前用来记录元素个数的全局变量counterCells赋值给了as。
    • 在第二个if判断中，有几个具体的判断逻辑，这些判断逻辑任何一个为true，都会调用fullAddCount方法去实现元素个数累加。判断逻辑简单说明一下。
      • as==null 说明CounterCell数组还未初始化。
      • (m = as.length - 1) < 0 ，这个判断理论上来说不存在，因为一旦CounterCell被初始化，就意味着as.length长度是2，所以不可能出现结果小于0的情况，如果各位读者有其他理解可以反馈给笔者。
      • (a = as[ThreadLocalRandom.getProbe() & m]) == null说明CounterCell数组已经创建了，但是通过探针hash定位在数组中中没有对象实例，说明这个数组中还存在没有CounterCell实例对象的情况。
      • U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x)执行到了这个判断逻辑，说明当前CounterCell数组每个位置都有一个CounterCell实例对象，直接通过CAS操作针对上一个步骤获取到的CounterCell的value值进行累加，如果失败，说明存在竞争。
  • sumCount();返回总的元素个数，实际上应该就是CounterCell数组和baseCount两者累加计算的结果。

细心的读者不难发现，在if判断中，首先是执行(as = counterCells) != null，然后再尝试对baseCount做累加。这里有一个概率性的问题，就是当一个集合发生过并发时，后续发生并发的可能性会越高，这种思想在并发编程以及很多应用场景中都有体现。

fullAddCount方法分析

fullAddCount的主要功能有几个。

  • 如果CounterCell数组还未初始化，则先初始化。
  • 如果已经初始化，则随机找到其中一个值进行累加更新。
  • 如果线程竞争加剧，则会尝试对CounterCell数组进行扩容。

接下来，笔者分别针对这三个部分进行分析。

第一个部分，初始化CounterCell

CounterCell数组初始化处理不难理解。

  • cellsBusy == 0 && counterCells == as &&U.compareAndSwapInt(this, CELLSBUSY, 0, 1)这个部分，是通过CellsBusy字段来表示抢占到锁的标记，通过CAS修改CellsBusy=1来表示占有状态。
  • CounterCell[] rs = new CounterCell[2];构造一个长度为2的CounterCell数组。
  • rs[h & 1] = new CounterCell(x);，把当前增加的元素个数x保存到rs[h&1]的位置。
  • counterCells = rs;把rs赋值给全局对象counterCells。
private final void fullAddCount(long x, boolean wasUncontended) {
    //省略部分代码....
   for (;;) {
       CounterCell[] as; CounterCell a; int n; long v;
       if ((as = counterCells) != null && (n = as.length) > 0) {
           //省略部分代码....
       }
       else if (cellsBusy == 0 && counterCells == as &&
                U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
           boolean init = false;
           try {                           // Initialize table
               if (counterCells == as) {
                   CounterCell[] rs = new CounterCell[2];
                   rs[h & 1] = new CounterCell(x);
                   counterCells = rs;
                   init = true;
               }
           } finally {
               cellsBusy = 0;
           }
           if (init)
               break;
       }
   }
}

第二个部分，增加元素个数

如果CounterCell数组已经初始化了，也存在两种情况。

第一种情况是通过(a = as[(n - 1) & h]) == null计算到某个数组下标存在null的对象时，那么直接把当前要增加的元素个数x保存到数组中的某一个对象中即可。

  • (as = counterCells) != null && (n = as.length) > 0表示counterCells数组已经完成了初始化。
  • CounterCell r = new CounterCell(x);先创建一个CounterCell对象，把x保存进去。
  • U.compareAndSwapInt(this, CELLSBUSY, 0, 1)当前线程占用锁。
  • rs[j] = r，把新构建的保存了元素个数x的CounterCell对象保存到rs[j]的位置。
private final void fullAddCount(long x, boolean wasUncontended) {
    //省略部分代码....
   for (;;) {
       CounterCell[] as; CounterCell a; int n; long v;
       if ((as = counterCells) != null && (n = as.length) > 0) {
           if ((a = as[(n - 1) & h]) == null) {
               if (cellsBusy == 0) {            // Try to attach new Cell
                   CounterCell r = new CounterCell(x); // Optimistic create
                   if (cellsBusy == 0 &&
                       U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
                       boolean created = false;
                       try {               //Recheck under lock
                           CounterCell[] rs; int m, j;
                           if ((rs = counterCells) != null &&
                               (m = rs.length) > 0 &&
                               rs[j = (m - 1) & h] == null) {
                               rs[j] = r;
                               created = true;
                           }
                       } finally {
                           cellsBusy = 0;
                       }
                       if (created)
                           break;
                       continue;           // Slot is now non-empty
                   }
               }
               collide = false;
           }
           //省略部分代码....
       }
       //省略部分代码....
   }
}

第二种情况，就是直接通过U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x)操作，对CounterCell指定位置的元素进行累加。

private final void fullAddCount(long x, boolean wasUncontended) {
    //省略部分代码....
   for (;;) {
       //由于指定下标位置的cell值不为空，则直接通过cas进行原子累加，如果成功，则直接退出
       else if (U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))//
           break;
   }
  //省略部分代码....
}

第三个部分，CounterCell数组扩容

如果竞争比较激烈，也就是通过多次自旋（也就是线程无法满足上述的判断条件时），就会触发CounterCell的扩容。

  • cellsBusy == 0 &&U.compareAndSwapInt(this, CELLSBUSY, 0, 1)抢占锁。
  • CounterCell[] rs = new CounterCell[n << 1];在原有的基础上扩容一倍，再通过for循环进行数据迁移。
  • counterCells = rs;把扩容后的对象赋值给counterCells。
private final void fullAddCount(long x, boolean wasUncontended) {
    //省略代码....
    else if (cellsBusy == 0 &&
             U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
        try {
            if (counterCells == as) {// Expand table unless stale
                //扩容一倍 2变成4
                CounterCell[] rs = new CounterCell[n << 1];
                for (int i = 0; i < n; ++i)
                    rs[i] = as[i];
                counterCells = rs;
            }
        } finally {
            cellsBusy = 0;//恢复标识
        }
        collide = false;
        continue;//继续下一次自旋
    }
    //省略部分代码....
}

size()方法结果汇总

基于前面的分析，基本上我们也能猜测出它的整体实现，无非就是把baseCount和CounterCell保存的value进行累加即可。接下来我们看一下size()方法的定义如下。

public int size() {
    long n = sumCount();
    return ((n < 0L) ? 0 :
            (n > (long)Integer.MAX_VALUE) ? Integer.MAX_VALUE :
            (int)n);
}
final long sumCount() {
    CounterCell[] as = counterCells; CounterCell a;
    long sum = baseCount;
    if (as != null) {
        for (int i = 0; i < as.length; ++i) {
            if ((a = as[i]) != null)
                sum += a.value;
        }
    }
    return sum;
}

主要看一下sumCount这个方法，实现原理和我们猜想的一致。

  • 先得到baseCount的值，保存到sum这个字段中。
  • 遍历CounterCell数组，把数组中每个CounterCell中存储的value进行累加。

我们发现，size()方法在计算总的元素个数时，并没有加锁，所以size()方法返回的元素个数不一定代表总的容量。

跟着Mic学架构
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
必知必会--ConcurrentHashMap锁分段原理
星仔的博客
10-12 3028
前言 HashMap是线程不安全的类，JDK1.8之前多线程的情况下，如果多次put操作会导致死循环，尽管JDK1.8对HashMap进行了优化，但是HashMap并不是为了线程安全而设计的类，因此多线程下我们应该尽量避免使用HashMap。 Hashtable是线程安全的类，但是当Hashtable进行put操作时会将整个Hashtable对象锁起来，只允许一个线程向Hashtable中pu...
【数据类型】ConcurrentHashMap分段锁实现高并发；与HashMap的区别
代码的魅力，根本走不出来
01-15 1299
是 Java 中的线程安全的哈希表实现，它提供了一种高效的并发访问机制，适用于多线程环境。线程安全性： ConcurrentHashMap 提供了线程安全的操作。多个线程可以同时读取和修改映射，而不会导致数据不一致或抛出并发修改异常\color{green} {多个线程可以同时读取和修改映射，而不会导致数据不一致或抛出并发修改异常}多个线程可以同时读取和修改映射，而不会导致数据不一致或抛出并发修改异常。分段锁： ConcurrentHashMap 内部采用分段锁的机制，
说说ConcurrentHashMap原理与实现
学一次的博客
04-23 2103
原理与实现主要是锁的原理与实现！我们可以从JDK1.7开始聊起： JDK1.7版本, ConcurrentHashMap内部使用段(Segment), ConcurrentLevel 有16个分段，这16个分段有独立的锁机制，每个独立的机制都是一张表，表的下面是链表，这样就可以支持并发的同时保证每张表的线程安全，大大的题高了效率。 JDK1.8版本, ConcurrentHashMap内部使用sychronized + volatile + CAS 的实现降低锁的粒度
多线程（74）分段锁
最新发布
qq_43012298的博客
04-26 497
分段锁（Segmented Locking）是一种用于提高多线程程序性能的锁机制，通过将锁细分来减少竞争，从而在高并发环境中提高性能。分段锁在Java的中有广泛应用。
ConcurrentHashMap的实现原理是分段锁？你Out了
沛哥儿的专栏
11-21 1809
新版的ConcurrentHashMap和Segment分段锁没有任何关系。它的实现方式和HashMap有点大同小异：数组+链表+红黑树。
分段锁的理解
weixin_40616523的博客
01-13 1万+
总是记不清分段锁与ConcurrentHashMap的实现原理，今天来用自己的理解类比一下ConcurrentHashMap中分段锁的实现。 ConcurrentHashMap使用了分段锁来保证线程安全，效率比起使用synchronized的HashTable要高的很多。每个集合都可以看作是一个存储东西的房子，HashTable与ConcurrentHashMap存储的都是HashEntry数组...
Java基础-2、并发
u010313441的专栏
01-31 425
目录   synchronized Volatile 信号量Semaphore 实现所有线程在等待某个事件的发生才去执行 CAS缺陷以及如何解决 AQS 死锁、活锁 线程池 线程池的种类 配置线程池大小 工作机制及原理 ThreadPoolExecutor类 ThreadLoad原理 LockSupport工具 Condition原理 Fork/Join框架的理解...
java ConcurrentHashMap锁分段技术及原理详解
08-25
Java中的`ConcurrentHashMap`是线程安全的散列表，为多线程环境设计，它引入了一种称为“锁分段技术”的并发控制策略。在理解这个技术之前，我们需要回顾一下传统的线程不安全和低效的散列表，如`HashMap`和`...
ConcurrentHashMap的实现原理
09-07
其中，Segment 分段锁是 ConcurrentHashMap 中的核心组件，它继承自 ReentrantLock，内部拥有一个 Entry 数组，数组中的每个元素又是一个链表。这种结构使得 ConcurrentHashMap能够实现真正的并发访问。 ...
java中ConcurrentHashMap的读操作为什么不需要加锁
08-26
在Java 1.8中，`ConcurrentHashMap`摒弃了1.7版本的`Segment`分段锁设计，转而采用了`Node`节点、CAS（Compare and Swap）操作以及细粒度的锁策略。每个`Node`节点都可能带有锁，这使得并发性能得到显著提升。在读...
Java 中ConcurrentHashMap的实现
09-01
在`ConcurrentHashMap`的设计中，其核心思想是分段锁（Segment）策略，这使得它能够在多个线程并发读写时提供更好的性能。与`Hashtable`不同，`ConcurrentHashMap`不会锁定整个Map，而是将Map分成多个段（默认16个）...
ConcurrentHashMap的实现原理(JDK1.7和JDK1.8)
11-15
ConcurrentHashMap 的实现原理(JDK1.7 和JDK1.8) 一、哈希表 哈希表是一种以键-值(key...JDK1.7 和 JDK1.8 中的 ConcurrentHashMap 实现原理不同，但是它们都遵循着相同的设计目标：提高并发性能，减少锁竞争的影响。
7.Atomic系列之LongAdder的底层原理（分段锁提升并发性能）
qq_25830587的博客
05-22 258
这一章节我们就来讲解CAS带来的另外一个问题，在并发激烈的时候，产生大量的自旋，空耗CPU的问题，以及怎么使用分段锁机制解决这个问题的，我们以LongAdder这个原子类来举例讲解。AtomicInteger的缺陷：并发竞争激烈时导致大量线程自旋LongAdder采用分段锁的思想**，去减少并发竞争的；我打个比方还是上面10000个线程并发操作，但是LongAdder内部可能有10个锁，不同的线程可能去竞争不同的锁，平均下来可能是1000个线程竞争1个锁这样；并发性能这样比起AtomicInteger可能就
Java中的-自旋锁/偏向锁/轻量级锁/重量级锁/乐观锁/悲观锁/分段锁/分布式锁等
专注基础架构领域
03-20 518
如果互斥量是加锁的，那么线程会阻塞，当有多个线程被阻塞时，系统会随机的挑选一个线程获取锁。读写锁通过读锁和写锁来完成读写操作，线程在读取数据前要获取读锁，读锁在读线程之间是共享的，可以被多个线程持有，写锁是排他的，有一个线程获取到写锁之后，别的线程无法获取读锁和写锁，这样保证了数据的一致性。这个锁跟synchronized有关系，当锁对象第一次被线程A获取的时候，会记录线程A的id，之后在没有别的线程获取锁对象的前提下，线程A在执行这个锁对应的同步代码块时不会再进行任何同步操作，即这个。
ConcurrentHashMap原理详解(太细了)
热门推荐
qq_42068856的博客
07-31 5万+
和HashMap一样，是一个存放键值对的容器。使用hash算法来获取值的地址，因此时间复杂度是O(1)。查询非常快。同时，是线程安全的HashMap。专门用于多线程环境。做插入操作时，首先进入乐观锁，然后，在乐观锁中判断容器是否初始化，如果没初始化则初始化容器，如果已经初始化，则判断该hash位置的节点是否为空，如果为空，则通过CAS操作进行插入。如果该节点不为空，再判断容器是否在扩容中，如果在扩容，则帮助其扩容。如果没有扩容，则进行最后一步，先加锁，然后找到hash。......
【图解】面试题：ConcurrentHashMap是如何保证线程安全的
Mr 敦（A.Dun）Java历险记
04-25 2952
注意：JDK1.7与JDK1.8中的ConcurrentHashMap主要延续HashMap的设计与思想，是在其基础上进行的相应优化 1.JDK1.7中的底层实现原理 （1）JDK1.7ConcurrentHashMap的底层结构，延续HashMap的底层设计，采用数组+链表 （2）不同的是：ConcurrentHashMap中的数组被分为大数组和小数组，大数组是Segment，小数组是HashEntry Segment本身是基于ReentrantLock可重入锁来实现加锁和释放锁，这样就能保证多线程同.
ConcurrentHashMap实现原理
MR.Ting
03-29 1万+
ConcurrentHashMap是Java1.5中引用的一个线程安全的支持高并发的HashMap集合类。这篇文章总结了ConcurrentHashMap的内部实现原理，是对于自己理解后的一些整理。1.HashTable与ConcurrentHashMap的对比HashTable本身是线程安全的，写过Java程序的都知道通过加Synchronized关键字实现线程安全，这样对整张表加锁实现同步的一个
ConcurrentHashMap分段锁
JackMa的博客
04-18 605
是支持高并发的线程安全的 HashMap。相较于 HashTable 使用 synchronized 方法来保证线程安全，ConcurrentHashMap 采用分段锁的方式，在线程竞争激烈的情况下 ConcurrentHashMap 的效率高很多。ConcurrentHashMap 中的分段锁称为 Segment，它的内部结构是维护一个 HashEntry 数组，同时 Segment 还继承了 ReentrantLock。
对于分段锁的简单理解
whalesharks的博客
11-03 805
总是记不清分段锁与ConcurrentHashMap的实现原理，今天来用自己的理解类比一下ConcurrentHashMap中分段锁的实现。 ConcurrentHashMap使用了分段锁来保证线程安全，效率比起使用synchronized的HashTable要高的很多。每个集合都可以看作是一个存储东西的房子，HashTable与ConcurrentHashMap存储的都是HashEntry数组（每个数组里面是链表，暂且忽略，直到就好）。 HashTable: 在HashTable这个房子中，只有一个房间
ConcurrentHashMap 分段锁原理
08-03
回答: ConcurrentHashMap采用了锁分段的技术来实现线程安全。锁分段是指将整个容器分成多个段（Segment），每个段都有自己的锁。这样不同的线程可以同时对不同的段进行写操作，从而提高了并发性能。每个段内部使用了与传统的HashMap类似的数据结构，即数组+链表/红黑树的形式来存储键值对。当进行写操作时，只需要锁住对应的段，而不需要锁住整个容器。这样就减小了锁的粒度，提高了并发度。[1] ConcurrentHashMap的put()方法是其中一个重要的方法，通过分析put()方法可以了解到ConcurrentHashMap的锁分段机制。在put()方法中，会根据键的哈希值找到对应的段，然后在该段上进行插入操作。[2]每个段都有自己的锁，因此不同的线程可以同时对不同的段进行写操作，从而提高了并发性能。这种锁分段的设计可以有效地减少锁竞争，提高了ConcurrentHashMap的并发性能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

跟着Mic学架构

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值