ConcurrentHashMap详解 什么时候CAS什么时候synchronized

最新推荐文章于 2025-03-24 16:45:44 发布
最新推荐文章于 2025-03-24 16:45:44 发布
阅读量897 收藏 8
点赞数 4
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42649617/article/details/139407978
版权

jdk:1.7 segment数组+hashEntry数组+链表实现

jdk版本：1.8：hashEntry+数组+红黑树实现

1、基本参数

//**1、最大容量**  hashmap的最大容量也是这个，菜鸟一面被问到了
private static final int MAXIMUM_CAPACITY = 1 << 30;

//数组默认为16
private static final int DEFAULT_CONCURRENCY_LEVEL = 16;

//float浮点数，LOAD_FACTOR为final 不可更改
private static final float LOAD_FACTOR = 0.75f;

2、初始化1

也就是说不是你输入什么就是什么容量，内部还有一个算法优化用户的输入。（防止用户输入参数太差）  
//逻辑：如果init>max的一半，则返回max，否则返回tableSizeFor(init + (initialCapacity >>> 1) + 1)); 
public ConcurrentHashMap(int init) {
        if (init < 0)
            throw new IllegalArgumentException();
        int cap = ((init >= (MAXIMUM_CAPACITY >>> 1)) ?
                   MAXIMUM_CAPACITY :
                   tableSizeFor(init + (init >>> 1) + 1));
        this.sizeCtl = cap;    //`sizeCtl` 表示容量
}
    
 //c=2返回2，c=3返回4，c=9返回16
//tableSizeFor 方法通过一系列位操作，将输入值 c 转换为大于或等于 c 的最小 2 的幂次方。这是为了确保哈希表的数组大小总是 2 的幂次方，从而优化哈希分布和查找性能。
 private static final int tableSizeFor(int c) {
    int n = c - 1;
    n |= n >>> 1;
    n |= n >>> 2;
    n |= n >>> 4;
    n |= n >>> 8;
    n |= n >>> 16;
    return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}

初始化2

 public ConcurrentHashMap(int initialCapacity,
                             float loadFactor, int concurrencyLevel) {
        if (!(loadFactor > 0.0f) || initialCapacity < 0 || concurrencyLevel <= 0)
            throw new IllegalArgumentException();
        if (initialCapacity < concurrencyLevel)   // Use at least as many bins
            initialCapacity = concurrencyLevel;   // as estimated threads
     
     	//非常神奇啊，传入的loadFactor不会改变装填因子，但是会改变传入的容量参数，影响最终容量
        long size = (long)(1.0 + (long)initialCapacity / loadFactor);
        int cap = (size >= (long)MAXIMUM_CAPACITY) ?
            MAXIMUM_CAPACITY : tableSizeFor((int)size);
        this.sizeCtl = cap;
    }

3、sizeCtl 不太理解

sizeCtl 是 ConcurrentHashMap 中一个非常重要且复杂的控制字段，其作用有很多个。

addCount()里面判断是否要扩容是和sizeCtl比较，而不是和装填因子比较。为什么使用 sizeCtl 而不是直接使用负载因子？

  1. 简化计算：
    • 通过将负载因子的计算隐式地包含在 sizeCtl 中，可以避免每次插入或删除元素时重新计算负载因子，从而减少了计算开销。
  2. 并发控制：
    • 使用 sizeCtl 可以有效地协调多个线程同时进行扩容操作。负值表示正在扩容，并且包含扩容的状态信息。这样，可以避免多个线程重复触发扩容。
  3. 性能优化：
    • 在高并发环境下，频繁访问和修改共享变量（如负载因子）会带来性能瓶颈。通过使用 sizeCtl，可以减少这种共享变量的访问次数，从而提高性能。
// Unsafe mechanics
    private static final long SIZECTL;
//初始化map时候，
	this.sizectl = cap; //cap为容量
	//比如
  public ConcurrentHashMap(Map<? extends K, ? extends V> m) {
        this.sizeCtl = DEFAULT_CAPACITY;
        putAll(m);
    }

在扩容期间：

当扩容开始时，sizeCtl 被设置为一个负值，表示当前参与扩容的线程数量。这样其他线程可以知道表正在扩容并可以协同进行扩容操作。

4、put 重点

public V put(K key, V value) {
        return putVal(key, value, false);
    }

    /** Implementation for put and putIfAbsent */
    final V putVal(K key, V value, boolean onlyIfAbsent) {
        //1、数据检查
        if (key == null || value == null) throw new NullPointerException();
        
        //2、求key哈希
        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)  //检查 table 是否初始化
                tab = initTable();
            //使用哈希值计算索引 i 并检查该位置是否为空。如果为空，使用 CAS 操作插入新节点，并跳出循环。
            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) // MOVEDd标志用于判断是否已经节点迁移
                //当一个桶（bin）中的所有节点都被迁移到新的数组中后，原来的位置上会放置一个特殊的转发节点，表示这个桶已经处理完毕。此时，转发节点的 hash 字段会被设置为 MOVED（即 -1）。
                tab = helpTransfer(tab, f);//协助迁移
            else {   //如果碰撞了  需要使用synchronized，放弃cas,f是table那个碰撞节点
                V oldVal = null;
                synchronized (f) {
                    if (tabAt(tab, i) == f) { // 经典的双重检查，防止当前线程获取table锁之前，tabAt(tab, i)被其它线程改变了
                        if (fh >= 0) {// 哈希值>=0代表是链表，<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)))) {  // 三比较，hashcode==hashcode，key==key,key.equals(key)
                                    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;  //binCount 被初始化为 2，因为红黑树中的节点数计算方式不同于链表。 具体原因我不知道
                            if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
                                                           value)) != null) {
                                oldVal = p.val;
                                if (!onlyIfAbsent)
                                    p.val = value;
                            }
                        }
                    }
                }
                if (binCount != 0) {   // 判断是否要扩容 TREEIFY_THRESHOLD=8
                    if (binCount >= TREEIFY_THRESHOLD)
                        treeifyBin(tab, i);
                    if (oldVal != null)
                        return oldVal;
                    break;
                }
            }
        }
        addCount(1L, binCount);  //计数 里面通过cas维护元素个数。
        return null;
    }

总结：

  1. 判断key value是否合法 判null
  2. 求key哈希
  3. 判断table是否初始化，如果没有就初始化
  4. 找到key哈希在table中的位置，判断是否为null
    1. 如果是Null则cas直接添加节点
    2. 如果碰撞了 需要使用synchronized（f）{}，放弃cas,f是table那个碰撞节点
      1. 如果f.hash>=0，则说明是链表，遍历查找，当(hashhash && keykey && key.equals(key))的时候返回元素。下一个节点为null还没有找到，则插入节点
      2. 如果f.hash<0, 则说明是红黑树，遍历查找。找不到就插入。
    3. 判断是否要转化为红黑树
  5. 调用addCount（）计算map总的元素个数，内部通过cas来实现。
    1. 这里面会检查table要不要扩容

**5、remove(Object key) **和put差不多

 final V replaceNode(Object key, V value, Object cv) {
        int hash = spread(key.hashCode());
        for (Node<K,V>[] tab = table;;) {
            Node<K,V> f; int n, i, fh;
            if (tab == null || (n = tab.length) == 0 ||
                (f = tabAt(tab, i = (n - 1) & hash)) == null)    // 空直接返回 没得删
                break;
            else if ((fh = f.hash) == MOVED)
                tab = helpTransfer(tab, f);
            else {          //不空则锁起来 再遍历 找到就删
                V oldVal = null;
                boolean validated = false;
                synchronized (f) {
                    if (tabAt(tab, i) == f) {
                        if (fh >= 0) {  // hash>=0 链表
                            validated = true;
                            for (Node<K,V> e = f, pred = null;;) {
                                K ek;
                                if (e.hash == hash &&
                                    ((ek = e.key) == key ||
                                     (ek != null && key.equals(ek)))) {
                                    V ev = e.val;
                                    if (cv == null || cv == ev ||
                                        (ev != null && cv.equals(ev))) {
                                        oldVal = ev;
                                        if (value != null)
                                            e.val = value;
                                        else if (pred != null)
                                            pred.next = e.next;
                                        else
                                            setTabAt(tab, i, e.next);
                                    }
                                    break;
                                }
                                pred = e;
                                if ((e = e.next) == null //找不到
                                    break;
                            }
                        }
                        else if (f instanceof TreeBin) {
                            validated = true;
                            TreeBin<K,V> t = (TreeBin<K,V>)f;
                            TreeNode<K,V> r, p;
                            if ((r = t.root) != null &&
                                (p = r.findTreeNode(hash, key, null)) != null) {
                                V pv = p.val;
                                if (cv == null || cv == pv ||
                                    (pv != null && cv.equals(pv))) {
                                    oldVal = pv;
                                    if (value != null)
                                        p.val = value;
                                    else if (t.removeTreeNode(p))
                                        setTabAt(tab, i, untreeify(t.first));
                                }
                            }
                        }
                    }
                }
                if (validated) {     // 计数
                    if (oldVal != null) {
                        if (value == null)
                            addCount(-1L, -1);
                        return oldVal;
                    }
                    break;
                }
            }
        }
        return null;
    }

6、get(Object key)

public V get(Object key) {
    // 定义一些局部变量
    Node<K,V>[] tab; 
    Node<K,V> e, p; 
    int n, eh; 
    K ek;

    // 计算键的哈希值，并进行哈希值扩散以减少碰撞
    int h = spread(key.hashCode());

    // 如果哈希表不为空并且哈希表长度大于0
    if ((tab = table) != null && (n = tab.length) > 0 &&

        // 计算哈希表索引，取出对应位置的节点
        (e = tabAt(tab, (n - 1) & h)) != null) {

        // 如果找到的节点的哈希值等于目标哈希值
        if ((eh = e.hash) == h) {

            // 并且键也相等（引用相等或 equals 相等），则返回该节点的值
            if ((ek = e.key) == key || (ek != null && key.equals(ek)))
                return e.val;
        }

        // 如果节点的哈希值小于0，表示该节点是一个特殊节点（如红黑树节点或转移节点）
        else if (eh < 0)
            // 调用 find 方法在该节点中查找目标键对应的值
            return (p = e.find(h, key)) != null ? p.val : null;

        // 否则，遍历该链表中的所有节点
        while ((e = e.next) != null) {
            if (e.hash == h &&
                ((ek = e.key) == key || (ek != null && key.equals(ek))))
                return e.val;
        }
    }

    // 如果没有找到，返回 null
    return null;
}
南忆起初
关注
ConcurrentHashMap使用Node+CAS+synchronized实现线程安全
weixin_44893585的博客
02-29 4356
官网对ConcurrentHashMap的使用场景的介绍 //{Hashtable} is synchronized. If a //thread-safe implementation is not needed, it is recommended to use //{HashMap} in place of {@code Hashtable}. If a thread-safe //hi...
ConcurrentHashMap详解
m0_46628950的博客
07-03 1040
ConcurrentHashMap详解
ConcurrentHashMap中什么时候用CAS，什么时候用Synchronized
qingyuwp的博客
11-19 364
简单来说，CAS用于在数组中插入新的节点，synchronized用于在链表或红黑树中添加或删除节点。ConcurrentHashMap在JDK1.8中使用了CAS和synchronized来实现线程安全。
“浅浅深究”一下ConcurrentHashMap
最新发布
小脚鱼的博客
03-24 2236
ConcurrentHashMap底层原理
ConcurrentHashMap并发控制源码阅读：CAS与synchronized的应用场景分析
Yunwushenyanying的博客
08-31 1043
在ConcurrentHashMap的具体实现中，CAS机制和Synchronized协助进行并发控制
ConcurrentHashMap、synchronized与线程安全
热门推荐
我想跟代码谈谈
01-04 2万+
最近做的项目中遇到一个问题：明明用了ConcurrentHashMap，可是始终线程不安全 除去项目中的业务逻辑，简化后的代码如下： public class Test40 { public static void main(String[] args) throws InterruptedException { for (int i = 0; i < 10; i
JDK1.8中 ConcurrentHashMap 中的CAS 和 synchronized是如何使用的
willlu10的博客
06-12 8845
CAS：在判断数组中当前位置为null的时候，使用CAS来把这个新的Node写入数组中对应的位置 synchronized ：当数组中的指定位置不为空时，通过加锁来添加这个节点进入数组(链表<8)或者是红黑树（链表>=8） 详细过程看下面源码 final V putVal(K key, V value, boolean onlyIfAbsent) { if (key == null || value == null) throw new NullPointerEx
java8的ConcurrentHashMap为何放弃分段锁，为什么要使用CAS+Synchronized取代Segment+ReentrantLock
是小D吖！的博客
08-15 2190
原文地址：https://cloud.tencent.com/developer/article/1509556 今天突然被一个同事问到java8为何放弃分段锁，于是花了点时间针对这个问题进行了小小的总结。jdk1.7分段锁的实现和hashmap一样，在jdk1.7中ConcurrentHashMap的底层数据结构是数组加链表。和hashmap不同的是ConcurrentHashMap中存放的数据是一段段的，即由多个Segment(段)组成的。每个Segment中都有着类似于数组加链表的结构。关于Segme
ConcurrentHashMap 1.8为什么要使用CAS+Synchronized取代Segment+ReentrantLock
weixin_30808693的博客
09-24 1938
大家应该都知道ConcurrentHashMap在1.8的时候有了很大的改动,当然,我这里要说的改动不是指链表长度大于8就转为红黑树这种常识,我要说的是ConcurrentHashMap在1.8为什么用CAS+Synchronized取代Segment+ReentrantLock了 首先,我假设你对CAS,Synchronized,ReentrantLock这些知识很了解,并且知道AQS,自旋锁...
ConcurrentHashmap详解
wangjunjie0817的博客
07-22 622
简介 ConcurrentHashMap是hashMap的高性能并发版本 高性能的原因 ConcurrentHashMap允许多个修改操作并发进行，其关键在于使用了锁分离技术。它使用了多个锁来控制对hash表的不同部分进行的修改。内部使用段(Segment)来表示这些不同的部分，每个段其实就是一个小的hash table，只要多个修改操作发生在不同的段上，它们就可以并发进行。理论上 Concurr...
Java 多线程与并发(13-26)-JUC集合- ConcurrentHashMap详解.pdf
07-26
JDK 1.8对`ConcurrentHashMap`进行了重大优化，放弃了分段锁机制，而是使用了基于数组的链表和红黑树数据结构，并结合CAS（Compare and Swap，比较并交换）原语实现无锁或轻量级锁的并发控制。这种设计大大减少了锁...
ConcurrentHashMap 详解
guanxin0206的博客
03-23 646
它用来解决HashMap在多线程环境下不安全的问题，同时相比Hashtable和Collections.synchronizedMap()有更好的并发性能。：仅锁定单个桶（链表或红黑树的头节点），不同桶的修改互不阻塞。迁移策略：将旧数组划分为多个区间，线程协助迁移不同区间的数据。迁移时读操作：旧桶未迁移完时从旧桶读取，迁移后从新桶读取。：适用于高并发环境下的键值存储，需权衡一致性与性能。默认数组大小：16，负载因子：0.75。：每个线程负责迁移旧数组的一段区间。：红黑树的根容器，持有树的根节点。
石杉笔记（1) synchronized、CAS、ConcurrentHashMap、AQS、ReetrantLock、线程相关、内存模型、volatile
SmileTimLi的博客
03-20 1147
BAT 面试官问并发编程相关的问题 连环问： synchronized 实现原理、CAS 无锁化的原理、AQS 是什么、Lock锁、ConcurrentHashMap 的分段加锁的原理、线程池的原理、java内存模型、volatile 说一下、对java并发包有什么了解一连串的问题 1、说说synchronized 关键字的底层原理 在并发编程中存在线程安全问题，主要原因有： a.存...
ConcurrentHashMap原理分析（1.7与1.8）
青鸟飞鱼
05-02 1658
转自：https://www.cnblogs.com/study-everyday/p/6430462.html 前言 以前写过介绍HashMap的文章，文中提到过HashMap在put的时候，插入的元素超过了容量（由负载因子决定）的范围就会触发扩容操作，就是rehash，这个会重新将原数组的内容重新hash到新的扩容数组中，在多线程的环境下，存在同时其他的元素也在进行put操作，如果hash...
并发安全ConcurrentHashMap集合深入学习(持续更新)
s.lm的博客
04-19 1235
并发安全集合ConcurrentHashp深入学习
ConcurrentHashMap和CAS的关系
kfepiza的博客
07-25 1043
由于CAS操作只适用于简单的变量更新，并且当多个线程同时执行CAS操作时可能导致CPU资源浪费（因为只有一个线程的操作会成功，其他线程需要重新尝试），因此ConcurrentHashMap在实现线程安全性时还结合了其他机制，如synchronized锁、分段锁（在JDK 1.7及之前版本中）等。：在某些处理器上，尤其是在支持虚拟化的环境中，CPU可能会在执行CAS指令时发生异常中断，这时CAS操作会被打断，可能导致后续的操作依赖于中断前的旧状态，从而导致失败。（Compare-and-Swap）操作。
ConcurrentHashMap介绍
CSDN博客
01-19 1852
红黑树是一种特殊的平衡二叉树，首选具备了平衡二叉树的特点：左子树和右子数的高度差不会超过1，如果超过了，平衡二叉树就会基于左旋和右旋的操作，实现自平衡。每个节点必须是红色或者黑色。根节点必须是黑色。如果当前节点是红色，子节点必须是黑色所有叶子节点都是黑色。从任意节点到每个叶子节点的路径中，黑色节点的数量是相同的。当对红黑树进行增删操作时，可能会破坏平衡或者是特性，这是红黑树就需要基于左旋、右旋、变色来保证平衡和特性。
day09（二）-ConcurrentHashMap原理-CAS
NULL_YM
04-12 592
文章目录ConcurrentHashMap原理细节初始化添加元素扩容源码执行图 ConcurrentHashMap原理 我们都知道HashMap不是线程安全的，所以在处理并发的时候会出现问题。而HashTable虽然是线程安全的，但是是通过整个来加锁的方式，当一个线程在写操作的时候，另外的线程则不能进行读写。而ConcurrentHashMap则可以支持并发的读写。跟1.7版本相比，1.8版本又...
ConcurrentHashMap
lixihetuanzi的博客
02-13 127
ConcurrentHashMap 和 Hashtable 的区别 ConcurrentHashMap 和 Hashtable 的区别主要体现在实现线程安全的方式上不同。 底层数据结构： JDK1.7的 ConcurrentHashMap 底层采用 分段的数组+链表 实现，JDK1.8 采用的数据结构跟HashMap1.8的结构一样，数组+链表/红黑二叉树。Hashtable 和 JDK1.8 之...
深⼊浅出ConcurrentHashMap详解
01-21
- **细粒度锁定**：当更新某个特定位置的数据项时，只需要对该位置所属的那个 Segment 加锁即可，而不是像 Hashtable 或 synchronized Map那样对整个容器加全局锁。 随着 JDK 版本演进，在JDK 1.8之后版本中，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值