ConcurrentHashMap源码分析（二）

最新推荐文章于 2023-10-19 20:27:34 发布
最新推荐文章于 2023-10-19 20:27:34 发布
阅读量114 收藏
点赞数
分类专栏： HashMap源码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43911969/article/details/115432561
版权

目标

  1. 为什么ConcurrentHashMap1.8需要去除Segments分段锁
  2. 为什么ConcurrentHashMap1.8使用synchronized而不使用lock锁
  3. ConcurrentHashMap1.8如何基于Node节点实现锁机制
  4. ConcurrentHashMap多线程size++效率最高
  5. 多个线程同时执行CAS效率真的非常高吗
  6. ConcurrentHashMap1.8与ConcurrentHashMap1.7区别

前面我们看过了ConcurrentHashMap1.7的源码，现在看看ConcurrentHashMap1.8的源码。
ConcurrentHashMap1.8采用的数据结构是数组+链表+红黑树。
没错，你没看错，我也没写错，和HashMap的数据结构一模一样，那他是怎么保证线程安全的呢？使用CAS和synchronized锁来保证安全，使用synchronized锁住需要进行put的那个链表。
接下来看看源码吧。
先看他的无参构造。
在这里插入图片描述
可以看到这个无参构造是没有任何处理的，这也间接的说明了ConcurrentHashMap的初始化时懒加载。
看完这部分，我们看看put()方法。
在这里插入图片描述
和HashMap挺像的。都调用着putVal()方法，进入看看。

final V putVal(K key, V value, boolean onlyIfAbsent) {
     if (key == null || value == null) throw new NullPointerException();
     int hash = spread(key.hashCode());
     int binCount = 0;
     for (Node<K,V>[] tab = table;;) {
         Node<K,V> f; int n, i, fh;
         if (tab == null || (n = tab.length) == 0)
             tab = initTable();
         else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
             if (casTabAt(tab, i, null,
                          new Node<K,V>(hash, key, value, null)))
                 break;                   // no lock when adding to empty bin
         }
         else if ((fh = f.hash) == MOVED)
             tab = helpTransfer(tab, f);
         else {
             V oldVal = null;
             synchronized (f) {
                 if (tabAt(tab, i) == f) {
                     if (fh >= 0) {
                         binCount = 1;
                         for (Node<K,V> e = f;; ++binCount) {
                             K ek;
                             if (e.hash == hash &&
                                 ((ek = e.key) == key ||
                                  (ek != null && key.equals(ek)))) {
                                 oldVal = e.val;
                                 if (!onlyIfAbsent)
                                     e.val = value;
                                 break;
                             }
                             Node<K,V> pred = e;
                             if ((e = e.next) == null) {
                                 pred.next = new Node<K,V>(hash, key,
                                                           value, null);
                                 break;
                             }
                         }
                     }
                     else if (f instanceof TreeBin) {
                         Node<K,V> p;
                         binCount = 2;
                         if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
                                                        value)) != null) {
                             oldVal = p.val;
                             if (!onlyIfAbsent)
                                 p.val = value;
                         }
                     }
                 }
             }
             if (binCount != 0) {
                 if (binCount >= TREEIFY_THRESHOLD)
                     treeifyBin(tab, i);
                 if (oldVal != null)
                     return oldVal;
                 break;
             }
         }
     }
     addCount(1L, binCount);
     return null;
 }

其实我们要是阅读过了HashMap那一篇文章，这一部分应该就都看懂了。

  1. if (key == null || value == null)
    ConcurrentHashMap不支持key和value为空
  2. int hash = spread(key.hashCode());
    计算hash值
  3. int binCount = 0;
    记录链表的长度，达到转为红黑树的要求就进行转换
  4. for (Node<K,V>[] tab = table;;)
    进行死循环，说好听点就是自旋，自旋我们在1.7也详细的说过了。
  5. if (tab == null || (n = tab.length) == 0)
    如果全局table是空数据，那么就进行初始化。后面再来详细的说说怎么初始化
  6. (f = tabAt(tab, i = (n - 1) & hash)) == null
    计算index值，并且拿到该下标的数组，若为空，那就创建新的链表
static final <K,V> Node<K,V> tabAt(Node<K,V>[] tab, int i) {
        return (Node<K,V>)U.getObjectVolatile(tab, ((long)i << ASHIFT) + ABASE);
    }
  1. casTabAt(tab, i, null,new Node<K,V>(hash, key, value, null))
    创建新的链表
static final <K,V> boolean casTabAt(Node<K,V>[] tab, int i,
                                        Node<K,V> c, Node<K,V> v) {
    return U.compareAndSwapObject(tab, ((long)i << ASHIFT) + ABASE, c, v);
 }
  1. (fh = f.hash) == MOVED
    若为-1，代表着有线程正在进行扩容，那么就帮其进行扩容
  2. synchronized (f)
    对数组的链表进行加锁，为什么之前没有使用 synchronized 锁，因为在jdk1.5的时候，synchronized 没有做任何的优化，在jdk1.6的时候，添加了自旋的功能，和之前使用tryLock()实现自旋一个效果。
  3. tabAt(tab, i) == f
    判断之前拿到的 f 是否和现在的拿到的链表一样。若不同则再次自旋，拿到新的链表f
  4. e.hash == hash && ((ek = e.key) == key || (ek != null && key.equals(ek)))
    若key一模一样，则直接替换原来的value
  5. (e = e.next) == null
    添加新数据到链表的尾部
  6. if (f instanceof TreeBin)
    若链表已经变成了红黑树，则将新数据添加到树种
  7. binCount >= TREEIFY_THRESHOLD
    若达到变成树的要求，则直接变成树。
  8. addCount(1L, binCount);对binCount进行自增，因为需要记录链表的的长度，但是ConcurrentHashMap是官方推荐在多线程使用的，所以使用了一个方法进行自增。

我们先来看看第5点，初始化table数组
tab = initTable();

private final Node<K,V>[] initTable() {
     Node<K,V>[] tab; int sc;
     while ((tab = table) == null || tab.length == 0) {
         if ((sc = sizeCtl) < 0)
             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;
 }
  1. (tab = table) == null || tab.length == 0
    再次判断table数组是否为空，并且将它作为自旋的判断条件。
  2. (sc = sizeCtl) < 0
    如果sizeCtl小于0，代表目前有线程正在进行数组的初始化,那么就释放此线程
  3. U.compareAndSwapInt(this, SIZECTL, sc, -1)
    从主内存中修改SIZECTL值，变相的告诉其他线程“我”正在初始化数组
  4. (tab = table) == null || tab.length == 0
    再次判断数组是否为空，若还是为空，那么就进行初始化了
  5. int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
    如果sc大于0，则直接利用默认的数组大小16进行初始化
  6. sc = n - (n >>> 2)
    这一段看似复杂，但其实还是很熟悉的，假如n为16，那么(n >>> 2)为4，那么sc的结果就是12，16*0.75=12，0.75加载因子 ，熟悉吧

在数组初始化这一段代码之中，存在一个bug，假如有两个线程，线程1、2均进入到else if部分。线程1完成了else if的数据更改，突然断电，线程1直接被结束了，那么线程2进行数据更改失败，又回到判空的while条件，发现table仍为空，但是sc为-1，所以线程被释放，修改数据sc又失败，那么线程2就会一直这样死循环下去，达不到break;

看完数组初始化，再来看看addCount(1L, binCount);方法

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();
        }
    }
}
  1. (as = counterCells) != null || !U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)
    判断 counterCells 是否为空。如果为空，就通过 cas 操作尝试修改 baseCount 变量，对这个变量进行原子累加操作 (如果在没有竞争的情况下，仍然采用 baseCount 来记录元素个数)
    2.如果 cas 失败说明存在竞争，这个时候不能再采用 baseCount 来累加，而是通过CounterCell 来记录
    这样就保证了线程的安全性，假如不这样使用，那么假如10多个线程同时进行CAS，只有一个线程成功，那么其他线程则会阻塞，导致效率及其慢
  2. boolean uncontended = true;
    线程是否冲突标识，默认没有冲突
  3. ThreadLocalRandom.getProbe() & m
    Random 在线程并发的时候会有性能问题以及可能会产生相同的随机数
    ThreadLocalRandom.getProbe 可以解决这个问题，并且性能要比 Random 高
  4. s = sumCount();
    对counterCells数组进行求和
  5. as == null || (m = as.length - 1) < 0 || (a = as[ThreadLocalRandom.getProbe() & m]) == null || !(uncontended = U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))
    1.计数表counterCells为空则直接调用 fullAddCount
    2.从计数表中随机取出一个数组的位置为空，直接调用 fullAddCount
    3.通过 CAS 修改 CounterCell 随机位置的值，如果修改失败说明出现并发情况，调用fullAndCount
  6. if (check <= 1)
    链表长度小于等于 1，不需要考虑扩容

为什么在全局变量中使用volatile？
加上volatile及时读取最新主内存数据，保证线程的可见性。

1.7和1.8的区别？
在put()方法中，1.7是需要计算两次index值，而1.8只需要计算一次，并且查询速度比1.7快。1.8取消了Lock锁，而使用synchronized。并且去掉了Segment分段锁

龙小虬
关注
专栏目录
Java并发系列之ConcurrentHashMap源码分析
08-27
Java并发系列之ConcurrentHashMap源码分析 ConcurrentHashMap是Java中一个高性能的哈希表实现，它解决了HashTable的同步问题，允许多线程同时操作哈希表，从而提高性能。 1. ConcurrentHashMap的成员变量： ...
ConcurrentHashMap源码分析源码分析
04-12
ConcurrentHashMap源码分析源码分析 代码解释非常详细！！！！
认真研究ConcurrentHashMap中的元素统计策略
小小默：进无止境
08-30 979
这里我们想研究的是jdk1.8中ConcurrentHashMap的`addCount(long x, int check)`方法。如下所示在put方法的最后会触发`addCount(long x, int check)`方法进行元素个数的统计。 ![在这里插入图片描述](https://img-blog.csdnimg.cn/910b40b954824bceb3a9cc4d61b6f8d1.png) 我们再回顾一下另一个参数binCount ： * 在操作链表的分支if (fh >= 0)中 用于统计
Java进阶篇--并发容器之ConcurrentHashMap
最新发布
m0_74293254的博客
10-19 357
具体来说，ConcurrentHashMap将哈希表分为多个段(Segment)，每个段都是一个独立的哈希表，且对于每个段的操作都是线程安全的。put方法是向ConcurrentHashMap中插入一个键值对，它首先会对key进行hash计算得到一个桶的位置，在该桶的位置上加锁，然后查找当前桶中是否已经存在该key，如果存在则替换掉原有的value，否则将该键值对插入到桶中。需要注意的是，在ConcurrentHashMap中，Node类型的元素是作为数组的元素存储的，因此需要使用位运算来计算内存地址。
ConcurrentHashMap学习
weixin_43216476的博客
08-22 161
研究背景： 在项目中遇到，由于HashMap的线程不安全，导致程序报错 如果多个线程同时访问一个哈希映射，并且至少有一个线程从结构上修改了该映射，则必须 保持同步。（结构上的修改是指添加或删除一个或多个映射关系的任何操作；仅改变与实例已经包含的键关联的值不是结构上的修改。）一般通过对自然封装该映射的对象进行同步操作来完成。如果不存在这样的对象，则应该使用 Collections.synchronizedMap 方法来“包装”该映射。最好在创建时完成这一操作，避免对映射进行意外的非同步访问，如下所示： Ma
ConcurrentHashMap
Lucifer ZHAO
05-30 8611
ConcurrentHashMap和HashMap原理基本类似，只是在HashMap的基础上需要支持并发操作，保证多线程情况下对HashMap操作的安全性。当某个线程对集合内的元素进行数据操作时，会锁定这个元素，如果其他线程操作的数据hash得到相同的位置，就必须等到这个线程释放锁之后才能进行操作。
第二章 ConcurrentHashMap源码分析（JDK8版本）1
08-04
在Java并发编程领域，`ConcurrentHashMap`是一个至关重要的类，它提供了线程安全的哈希映射功能，且性能优异。在JDK8中，`ConcurrentHashMap`的实现方式与之前的版本（如JDK6）有了显著变化，去除了Segment锁段的...
ConcurrentHashMap 详解（超详细 看不懂你锤我）
qq_41050869的博客
06-14 9638
ConcurrentHashMap介绍 ConcurrentHashMap是一个 在juc包下的 map， 线程安全。 在jdk.1.7 之前采用数组+ 链表的结构 并且采用分段锁机制 来保证线程安全，而jdk1.8之后 他改成了 数组+ 链表+ 红黑树，线程安全方面也改成了 cas+ synchronized 来保证线程安全。下面我们来看看ConcurrentHashMap的 源码是怎样实现的(jdk1.8) 属性 // 散列表最大容量 private static final int MAXIMUM_C
深入解析ConcurrentHashMap：感受并发编程智慧
一只修仙的猿
12-08 792
如果有一个整型变量count，多个线程并发让count自增1，你会怎么设计？ 你知道如何让多个线程协作完成一件事件吗？ 前言 很高兴遇见你~ ConcurrentHashMap是个老生常谈的集合类了，我们都知道多线程环境下不能直接使用HashMap，而需要使用ConcurrentHashMap，但有没有了解过ConcurrentHashMap到底是如何实现线程安全的呢？他到底跟传统的Hashtable和SynchronizeMap（没听过SynchronizeMap？他就是Collections.s..
j.u.c ConcurrentHashMap addCount方法
jupiter_888的博客
12-23 1351
j.u.c ConcurrentHashMap addCount方法 1、当总节点数量超过sizeCtl则对数组执行扩容操作； 将数组长度扩大为原来的2倍； 2、记录当前总节点的数量； 当添加、修改 元素都会触发判断数组是否需要扩容的操作： sizeCtl作为判断是否对数组进行2倍扩容的依据； sizeCtl= loaderFactor*当前数组长度； 一般loaderFactor...
ConcurrentHashMap实现原理及源码分析
weixin_43185598的博客
02-26 5万+
一、ConcurrentHashMap跟HashMap，HashTable的对比 HashMap不是线程安全： 在并发环境下，可能会形成环状链表（扩容时可能造成，具体原因自行百度google或查看源码分析），导致get操作时，cpu空转，所以，在并发环境中使用HashMap是非常危险的 HashTable是线程安全的： HashTable和HashMap的实现原理几乎一样， 差别：1.Ha...
ConcurrentHashmap的addCount(1)
luzhensmart的专栏
05-06 687
final V putVal(K key, V value, boolean onlyIfAbsent) { ... //高并发下的扩容 //如何保证addCount的数据安全性以及性能 //将当前ConcurrentHashMap的元素数量加1，有可能触发transfer操作(扩容) addCount(1L, binCount); return null; } /** *...
并发编程——ConcurrentHashMap#addCount() 分析
weixin_34284188的博客
05-19 637
前言 ConcurrentHashMap 精华代码很多，前面分析了 helpTransfer 和 transfer 和 putVal 方法，今天来分析一下 addCount 方法，该方法会在 putVal 方法中调用。 该方法可以配合 size 方法一起查看，关于该方法，楼主也写了一篇文章分析过：并发编程 —— ConcurrentHashMap size 方法原理分析 具体代码如下： addCo...
ConcurrentHashMap详解
热门推荐
唐芬奇的博客
03-28 8万+
文章目录spread()方法putVal()方法initTable()方法tryPresize()tableSizeFor()resizeStamp()transfer()总结compute()addCount() 计算成员数量sumCount()fullAddCount()资源锁sizeCtl其它节点类型forwarding节点ReservationNode节点 spread()方法 作用：用于获取槽位值 static final int spread(int h) { //h为k
ConcurrentHashMap底层详解(图解扩容)（JDK1.8）
愿万事胜意
06-13 2万+
数据结构 使用数组+链表+红黑树来实现，利用 CAS + synchronized 来保证并发更新的安全 源码分析 put方法 public V put(K key, V value) { return putVal(key, value, false); } final V putVal(K key, V value, boolean onlyIfAbsent) { if (key == null || value == null) throw
concurrentHashMap相关浅入
CSDN_lol的博客
08-05 182
一、什么是哈希表 在讨论哈希表之前，我们先大概了解下其他数据结构在新增，查找等基础操作执行性能 数组 采用一段连续的存储单元来存储数据。对于指定下标的查找，时间复杂度为O(1)； 通过给定值进行查找，需要遍历数组，逐一比对给定关键字和数组元素，时间复杂度为O(n)，当然，对于有序数组，则可采用二分查找，插值查找，斐波那契查找等方式，可将查找复杂度提高为O(logn)； 对于一般的插入删除操作，涉及到数组元素的移动，其平均复杂度也为O(n) 线性链表 对于链表的新增，删除等操作（在找到指定操作位置后），仅需
ConcurrentHashMap？你真的懂了吗？
Mark
08-08 1433
1、简介 1.1、继承关系和特点 ConcurrentHashMap是J.U.C(java.util.concurrent包)的重要成员，它是HashMap的一个线程安全的、支持高效并发的版本。 在默认理想状态下，ConcurrentHashMap可以支持16个线程执行并发写操作及任意数量线程的读操作。 1.2、底层结构 1.3、如何保证的线程的安全性 node + CAS + Synchronized 代替Segment 2、jdk7与jdk8的区别 取消了 segment 分段设计，.
ConcurrentHashMap 源码分析
08-11
- *2* *3* [ConcurrentHashMap源码分析](https://blog.csdn.net/java123456111/article/details/124883950)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

龙小虬

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

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

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

打赏作者

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

抵扣说明：

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

余额充值