【原理/Java容器】简单理解ConcurrentHashMap源码

已于 2023-08-30 14:57:29 修改
阅读量130 收藏
点赞数
文章标签： java 数据结构 哈希算法
于 2023-03-15 21:57:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Uracil/article/details/129562566
版权

文章目录

1 putVal(K, V, boolean)

向ConcurrentHashMap中放值都会走这个方法。

final V putVal(K key, V value, boolean onlyIfAbsent) {
		> ConcurrentHashMap中的key和value不允许为null
        if (key == null || value == null) throw new NullPointerException();
        
        > 根据key计算要插入的hash（spread方法见第2节）
		int hash = spread(key.hashCode());

		> 用于统计桶内的结点数量
        int binCount = 0;

		> 在这里自旋，获取当前的桶数组
        for (Node<K,V>[] tab = table;;) {

			> n -> 数组长度，i -> 计算出的要插入的桶的索引，fh -> 桶头结点哈希值
            Node<K,V> f; int n, i, fh;

			> 如果桶数组为空或者长度为0，初始化桶数组，见第3节
            if (tab == null || (n = tab.length) == 0)
                tab = initTable();

			> {i = (n - 1) & hash} -> {hash % n}，计算桶索引。f获取这个位置的Node
            else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {

				> 如果这个位置的Node为空，创建新的Node用CAS进行替换
				> casTabAt(数组, i, 2, 3) -> 以CAS将数组中i位置的数据从2修改为3
                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);

			> 出现了hash冲突，使用拉链法或添加到红黑树来解决
            else {
                V oldVal = null;

				> 给冲突所在的桶的头结点加上锁，就相当于锁住这个桶
                synchronized (f) {

					> 再次获取i位置的桶的头结点判断是否没有更换，更换就进入下次循环
                    if (tabAt(tab, i) == f) {

						> 【if0（方便对应下面else if）】头结点哈希值非负，说明是链表或者为空
                        if (fh >= 0) {

							> 桶结点数量设置为1
                            binCount = 1;

							> 遍历链表
                            for (Node<K,V> e = f;; ++binCount) {
                                K ek;

								> 发现相同key，进行修改
                                if (e.hash == hash &&
                                    ((ek = e.key) == key ||
                                     (ek != null && key.equals(ek)))) {
                                    oldVal = e.val;
                                    
                                    > 判断是否是缺失时才put，在putIfAbsent(..)方法调用
                                    if (!onlyIfAbsent)
                                        e.val = value;
                                    break;
                                }
                                
                                > 判断当前遍历到的Node的next是不是null，如果是就挂一个新Node，否则继续遍历
                                Node<K,V> pred = e;
                                if ((e = e.next) == null) {
                                    pred.next = new Node<K,V>(hash, key,
                                                              value, null);
                                    break;
                                }
                            }
                        }

						> 【if0】或者是红黑树
                        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) {
					
					> 插入后桶内结点数量达到树化阈值8，判断是否要转红黑树，见第4节
                    if (binCount >= TREEIFY_THRESHOLD)
                        treeifyBin(tab, i);
                        
                    if (oldVal != null)
                        return oldVal;
                    break;
                }
            }
        }
        addCount(1L, binCount);
        return null;
    }
... ...

2 spread(int)

用于二次哈希提高均匀性，传入了key.hashcode()。右移位16位让int类型的高16位与低16位异或，尽可能打散哈希值。
HASH_BITS是最大整型值，01111111 11111111 11111111 11111111，相与完保证hash为正，负数有特殊含义。

static final int spread(int h) {
    return (h ^ (h >>> 16)) & HASH_BITS;
}

3 initTable

用于初始化桶数组。

private final Node<K,V>[] initTable() {
    Node<K,V>[] tab; int sc;

    > 自旋判断数组是否还未初始化
    while ((tab = table) == null || tab.length == 0) {

		> {sizeCtl < -1} -> 正在扩容，-2表示有1个线程正在扩容，-3表示2个
		> {sizeCtl == -1} -> 数组正在初始化
		> {sizeCtl == 0} -> 还没有初始化
		> {sizeCtl > 0} -> 没初始化就是要初始化的长度，否则是扩容阈值

		> sizeCtl小于0表示正在扩容或者正在初始化，让出资源进入下一次循环。sc为当前sizeCtl
        if ((sc = sizeCtl) < 0) 
            Thread.yield(); // lost initialization race; just spin

		> sizeCtl大于等于0表示开始初始化过程，CAS替换SIZECTL为-1，大写的SIZECTL表示sizeCtl在对象中的偏移量
        else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
            try {
				
				> 再次判断，防止sizeCtl修改为非负之后其他线程进来在此创建
                if ((tab = table) == null || tab.length == 0) {

					> 如果sc>0，数组初始化长度设置为sc；否则16
                    int n = (sc > 0) ? sc : DEFAULT_CAPACITY;

					> 创建桶数组
                    @SuppressWarnings("unchecked")
                    Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
                    table = tab = nt;

					> 获取下一次扩容阈值，相当于{n - n/4} -> {0.75n}
                    sc = n - (n >>> 2);
                }
            } finally {
            	> 将sc赋值给成员变量sizeCtl
                sizeCtl = sc;
            }
            break;
        }
    }
    return tab;
}

4 treeifyBin(Node<K, V>[], int)

private final void treeifyBin(Node<K,V>[] tab, int index) {
   Node<K,V> b; int n, sc;
    if (tab != null) {
    	> 获取桶数组长度是否小于64，是则先扩容。因为在数组中查找比红黑树更快，尽量先尝试打散
        if ((n = tab.length) < MIN_TREEIFY_CAPACITY)
        	
        	> 扩容数组，见第5节
            tryPresize(n << 1);

		> 转红黑树
        else if ((b = tabAt(tab, index)) != null && b.hash >= 0) {
            synchronized (b) {
                if (tabAt(tab, index) == b) {
                    TreeNode<K,V> hd = null, tl = null;
                    for (Node<K,V> e = b; e != null; e = e.next) {
                        TreeNode<K,V> p =
                            new TreeNode<K,V>(e.hash, e.key, e.val,
                                              null, null);
                        if ((p.prev = tl) == null)
                            hd = p;
                        else
                            tl.next = p;
                        tl = p;
                    }
                    setTabAt(tab, index, new TreeBin<K,V>(hd));
                }
            }
        }
    }
}

5 tryPresize(int)

private final void tryPresize(int size) {
	> 传入值size为当前数组长度 * 2
	> 根据size计算扩容要求c。如果size达到最大容量2^30的一半，那就取最大容量；
	> 否则计算新容量tableSizeFor(1.5*size+1)，找到大于等于{1.5倍size+1}的最小的2的幂
    int c = (size >= (MAXIMUM_CAPACITY >>> 1)) ? MAXIMUM_CAPACITY :
        tableSizeFor(size + (size >>> 1) + 1);
    
    int sc;

	> 桶数组不一定已经初始化，putAll(..)会直接先执行tryPresize(..)
    while ((sc = sizeCtl) >= 0) {
	
		> 初始化数组的操作
        Node<K,V>[] tab = table; int n;
        if (tab == null || (n = tab.length) == 0) {
            n = (sc > c) ? sc : c;
            if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
                try {
                    if (table == tab) {
                        @SuppressWarnings("unchecked")
                        Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
                        table = nt;
                        sc = n - (n >>> 2);
                    }
                } finally {
                    sizeCtl = sc;
                }
            }
        }

		> c小于等于扩容阈值，或者已经数组长度已经最大了，表明不需要扩容，直接break
        else if (c <= sc || n >= MAXIMUM_CAPACITY)
            break;
            
        > 开始扩容
        else if (tab == table) {
        	> rs为扩容戳，记录本次扩容的标识。如果开始扩容会用于替换sizeCtl的高16位，后16位表示扩容线程数
            int rs = resizeStamp(n);
            
            > 已经开始扩容了，判断是否可以帮助扩容
            if (sc < 0) {
                Node<K,V>[] nt;

				> 如果sc右移16位后不等于rs，说明当前的扩容状态已经改变，不是同一次扩容，那么当前线程就不能参与扩容；
				> 如果sc等于rs+1，说明已经扩容完成，那么当前线程就不能参与扩容；
				> 如果sc等于rs+MAX_RESIZERS，说明已经达到了最大的扩容线程数，那么当前线程就不能参与扩容；
				> 如果nt为空，说明还没有初始化nextTable，那么当前线程就不能参与扩容；
				> 如果transferIndex小于等于0，说明已经没有剩余的数组元素需要迁移，那么当前线程就不能参与扩容。
                if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
                    sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
                    transferIndex <= 0)
                    break;
                
                > 否则就帮助扩容，增加sc表示多了一个扩容线程
                if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
                    transfer(tab, nt);
            }

			> 没有线程扩容，先设置sizeCtl标记，开始扩容
            else if (U.compareAndSwapInt(this, SIZECTL, sc,
                                         (rs << RESIZE_STAMP_SHIFT) + 2))
                transfer(tab, null);
        }
    }
}

附录

要想调试测试扩容建议key自己写一个类，比如这样：

public class ConcurrentHashMapTest {
    static class Key {

        int hashcode;
        public Key(int hashcode) {
            this.hashcode = hashcode;
        }

        @Override
        public int hashCode() {
            return hashcode;
        }
    }

    public static void main(String[] args) {
        ConcurrentHashMap<Key, Integer> map = new ConcurrentHashMap<>();
        map.put(new Key(1), 1);
        map.put(new Key(1), 2);
        map.put(new Key(1), 3);
        map.put(new Key(1), 4);
        map.put(new Key(1), 5);
        map.put(new Key(1), 6);
        map.put(new Key(1), 7);
        map.put(new Key(1), 8);
        map.put(new Key(1), 9);
    }
}

这样它们就都会加在table[1]的位置上，方便看扩容。

丑橘u
关注
java并发容器ConcurrentHashMap源码分析，springboot入门最详细教程
m0_64204730的博客
11-17 248
Creates a new, empty map with the specified initial capacity, load factor and concurrency level. @param initialCapacity the initial capacity. The implementation performs internal sizing to accommodate this many elements. @param loadFactor the l..
java并发容器ConcurrentHashMap源码分析，java分布式面试题及答案
m0_64867003的博客
12-17 158
2.1 ConcurrentHashMap构造方法与数据结构分析 /** Creates a new, empty map with the specified initial capacity, load factor and concurrency level. @param initialCapacity the initial capacity. The implementation performs internal sizing to accommodate this man
concurrentHashMap 源码理解
骑着蜗牛向前跑的博客
05-30 315
一、table 的初始化 table 数组的第一次初始化会发成在 putVal 的时候，但是在构造器中已经设置了容量和阈值。 1、无参构造函数 // 默认容量是 16. public ConcurrentHashMap() {} ##2、带初始容量的有参构造函数 如果提前能知道容量的大小，可以在创建对象时就给出初始容量。 public ConcurrentHashMap(int initialCapacity) { // 下限检测 if (initialCapaci
ConsurrentHashMap InitTable 疑问与思考
花开的博客
07-27 257
第二个问题说到需要循环等待所有自然不可能提前return，那为什么不用sleep，因为我们并不知道另一个线程什么时候完成初始化，也就不知道sleep多少秒，多了、少了都不合适，所以干脆就让出cpu时间片，等下一次再看看，如果其他线程完成了初始化就返回，否则重复以上。ConsurrentHashMap作为单机下经常使用的一个线程安全Map值得我们学习一下，以下其初始化的过程的代码，以及学习过程中遇到的疑惑与自己的思考。通常意义下的加锁，都是去检查一个东西是否被“其他”持有，如果被持有则本次加锁尝试失败。...
ConcurrentHashMap源码详解
qq_40276626的博客
08-30 2389
ConcurrentHashMap简介 ConcurrentHashMap是HashMap的同步容器，是线程安全的。 ConcurrentHashMap通过CAS和Synchronized来实现线程安全！ ConcurrentHashMap源码详解 public V put(K key, V value) { return putVal(key, value, false); } static final int spread(int h) { //HASH_BITS = 0x7fffff
ConcurrentHashMap的initTable()
luzhensmart的专栏
05-06 526
private final Node<K,V>[] initTable() { Node<K,V>[] tab; int sc; while ((tab = table) == null || tab.length == 0) { //被其他线程抢了初始化的操作,则直接让出自己的cpu时间片 ...
ConcurrentHashMap 成员、方法分析
最新发布
qq_37436172的博客
12-03 507
ConcurrentHashMap构造函数的负载因子 与hashMap的负载因子不同。ConcurrentHashMap构造中的负载因子的作用是，与initialCapacity一起确定ConcurrentHashMap容量的大小，后续扩容使用的都是默认0.75的负载因子进行扩容
Java容器之ConcurrentHashMap源码分析（JDK 1.7与JDK 1.8对比）
hestyle的博客
04-14 593
  在前面两篇博客 Java容器之HashMap源码分析、Java容器之Hashtable源码分析分别对JDK1.8中的HashMap、Hashtable的源码进行一些分析，在本篇博客将对ConcurrentHashMap容器的源码进行一些分析。 申明：在前两篇博客介绍了两个容器的增、删、改、查相关的API，并且给源码加上了中文注释，在本篇博客将只介绍一些关键的API，比如hash值的计算，put...
Java8之ConcurrentHashMap实现原理
ddxd0406的博客
08-05 9184
在java8之前ConcurrentHashMap是使用分段锁来实现并发的，数据结构为hashmap（数组加链表）的基础上再套一层segment数组，锁加在segment元素上。java8实现了粒度更细的加锁，去掉了segment数组，直接使用synchronized锁住hash后得到的数组下标位置中的第一个元素 ，如下图，这样加锁比segment加锁能支持更高的并发量。 另外，在java8...
ConcurrentHashMap底层实现原理
weixin_51749366的博客
12-02 212
node节点 static class Node<K,V> implements Map.Entry<K,V> { //Node 节点 final int hash; //哈希值 final K key; //键 volatile V val;//值 volatile Node<K,V> next; //下一节点 Node(int hash, K key, V val, Node<K,V> next) { //构造函数 this
这么回答面试官之--ConcurrentHashMap如何put？
进击的Coder*的博客
04-10 5440
final V putVal(K key, V value, boolean onlyIfAbsent) { if (key == null || value == null) throw new NullPointerException(); // 根据key计算出hash code int hash = spread(key.hashCode()); int binCount = 0; for (Node<K,V&g.
ConCurrentHashMap源码分析
qq_22610595的博客
09-19 354
本文主要从个人角度着重讲解了ConcurrentHashMap的部分代码。从源码的角度出发，大胆猜测并解释作者的意图。从而学习作者的在代码实现上的优秀思想。 文章目录一、关键属性二、关键方法1.ConcurrentHashMap(int initialCapacity)2. putVal(K key, V value, boolean onlyIfAbsent)3. initTable()4. putTreeVal(hash, key, value)5. balanceInsertion(root, x.
jdk1.8 ConcurrentHashMap 源码学习
dewp8551的博客
05-11 122
上次讲到HashMap，但是HashMap并不是线程安全的，那么有哪些线程安全的Map或者是实现线程安全的map呢？ 1、 HashTable（已弃用），使用的是内置对象锁对map进行同步，并发执行的效率比较低（key和value均不能为null，因为这是用在多线程的，当get返回null时，无法确定是不包含这个key还是值为null，hashMap允许key为null，因为运行...
ConcurrentHashMap源码分析
JeremyJiaming的博客
09-01 222
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 new NullPointerExc...
Map源码解析之ConcurrentHashMap(JDK1.8)(一)
翻身已碰头的博客
03-06 745
Map源码解析之HashMap Map源码解析之HashMap红黑树 Map源码解析之HashMap补充：集合、迭代器、compute、merge、replace Map源码解析之LinkedHashMap Map源码解析之TreeMap Map源码解析之HashTable 一、简述 HashMap和LinkedHashMap都不是线程安全的，而线程安全的HashTable和Collections...
java 集合（4）：线程安全
Mr_tianyanxiaobai的博客
08-12 236
Vector Vector集合是对ArrayList集合线程安全的实现，它们两者在方法的实现上没有什么太大的区别，最大的区别就是，Vector在方法前面加上了synchronized 关键字，用于保证线程安全。 具体可以查看：这里 Vector存在的问题： 1、它的 add() 和 get() 方法都能够获取当前 Vector 对象的对象锁，但是有可能会发生读读互斥。 2、当 threadA 在1 下标处添加一个元素，threadB在2下标处修改一个元素时，同样有可能会发生互斥现象。 Vector
ConcurrentHashMap
qq_25050779的博客
11-21 589
1.8 https://processon.com/view/60cc62685653bb3c31f06a22 jdk 1.7中是基于segment数组然后通过ReentrantLock对每一个segment元素加锁，来保证每一个segment内线程操作的安全性，从而保证了所有线程的操作安全； 其中：默认的segment数组长度是16，也就是说concurrenthashmap1.7默认的并发度是16； 1.8中直接取消segment数组，采用和hashmap相同的结构 ：Node数组+链表+红黑树；每
ConcurrentHashMap源码解析（下）
qq_50313418的博客
01-22 1012
6. 成员方法 6.1 一些辅助方法 spread(int h)方法 这个方法是计算Node结点的hash值的，在计算哈希值时将h的高位也用到，是为了使散列表更加分散。 // 0x7fffffff转化为2进制就是1111111111111111111111111111111 // HASH_BITS的值就是1111111111111111111111111111111 // 这里用h^（h>>>16）是为了在计算哈希值时将h的高位也用到，使散列表更加分散 static final int
Java并发包深入解析：ConcurrentHashMap源码探秘
"深入学习java并发包ConcurrentHashMap，分析其源码，了解其Segment分段锁机制，以及并发级别的概念和初始化参数设定" 在Java并发编程中，`ConcurrentHashMap`是一个非常重要的数据结构，它是线程安全的HashMap实现...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值