ConcurrentHashmap源码阅读（总结）

最新推荐文章于 2026-05-06 15:28:17 发布
原创 最新推荐文章于 2026-05-06 15:28:17 发布 · 712 阅读 · 12 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
收录于
java基础源码阅读

当前文章被收录于：

java基础源码阅读
8 篇文章 0 人学习

Java源码

订阅专栏 查看详情
一、概念

ConcurrentHashmap 是一个线程安全的哈希表，用于高并发下的读写操作。属于JUC中的一个工具类。与Hashmap和HashTable不同，线程安全且效率相对较高，使用的hash桶的分段锁保证线程安全。

二、  常见函数
1.  构造函数

● ConcurrentHashmap() 创建一个空的集合。

● ConcurrentHashmap(int initialCapacity) 创建一个初始容量为 initialCapacity 最近2的幂的集合。

● ConcurrentHashmap(Map <? extends K, ? extends V> m) 创建一个包含指定元素的集合。

● ConcurrentHashmap(int initialCapacity, float loadfactor) 创建一个指定容量和指定加载因子的集合。

● ConcurrentHashmap(int initialCapacity, float loadfactor, int concurrencyLevel) 创建一个指定容量和特定加载因子的集合（并没有看到这个并发级别的具体作用）。

2.  添加元素

● V put(K key, V value) 向集合添加一个key,value键值对。

● void putAll(Map<? extends K , ? extends V > m) 将m中的所有映射关系添加到当前集合中。

● V putIfAbsent() 添加新元素，若key已存在，不替换，除非值为 null

3.  获取元素

● V get(k key) 根据key获取映射对应的值。

● Conllection<V> values() 获取所有映射的value的集合。

● KeySetView<K,V> keySet() 获取所有映射key的set集合。

● Set<Map.Entry<K,V>> entrySet() 获取集合所有映射的set集合，用于遍历集合较多。

4.  移除元素

● V remove(K key) 移除集合中key对应的映射关系，并返回对应的value。

● boolean remove(Object key, Object value) 移除指定 key 的元素，但对应key节点的value必须与 传入的value值相等，才会进行删除，返回值为 boolean。

● void clear() 清除集合中所有映射关系。

5.  大小和状态

● int size() 获取集合大小。

● boolean isEmpty() 判断集合是否为空。

● boolean containsKey(Object key) 判断是否包函对应key的映射。

● boolean containVaue(Object value) 判断集合是否包涵值为value的映射。

● int hashCode() 获取集合的hashcode值。

6.  迭代

● Iterator<E> iterator(): 返回在此集合的元素上进行迭代的迭代器。请注意，迭代器是弱一致性的。

三、  使用场景
1、  共享缓存

                多线程环境下，可以安全地进行缓存的读写操作。

2、  分布式锁

                可以利用ConcurrentHashmap 的 putIfAbsent 方法实现轻量级的分布式锁

     3、保存临时对象状态

                存储连接对象，存储会话对象，例如 Web 服务器的会话存储。

四、源码阅读
1.  put方法源码
public V put(K key, V value) {
        return putVal(key, value, false);
    }
final V putVal(K key, V value, boolean onlyIfAbsent) {
        //新增的 key 或者 value 为bull 抛出空指针异常
        if (key == null || value == null) throw new NullPointerException();
        //计算key的hash散列
        int hash = spread(key.hashCode());
        int binCount = 0;
        for (Node<K,V>[] tab = table;;) {
            Node<K,V> f; int n, i, fh;
            // 数组tab 没有被初始化，进行初始化
            if (tab == null || (n = tab.length) == 0)
                tab = initTable();
            // 数组该位置没有元素，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;                  
            }
            // f的hash为moved 说明正在扩容，尝试加入扩容队列
            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)))) {
                                     //桶里元素的key与新加key一致
                                    oldVal = e.val;
                                    //判断是否替换原有的value
                                    if (!onlyIfAbsent)
                                        e.val = value;
                                    break;
                                }
                                // 不存在key一致元素，在链表后面添加元素
                                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) {
                    //判断链表长度，如果链表长度大于8 尝试将链表转成树
                    if (binCount >= TREEIFY_THRESHOLD)
                        treeifyBin(tab, i);
                    if (oldVal != null)
                        return oldVal;
                    break;
                }
            }
        }
        addCount(1L, binCount);
        return null;
    }
2.  transfer () 扩容方法
private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
        int n = tab.length, stride;
        // 根据NCPU计算扩容步长
        // 计算出最小的步长小于最小默认步长，设置步长为最小步长
        if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
            stride = MIN_TRANSFER_STRIDE; 
        //当nextTab 为null ,设置下一个数组为当前数组的两倍
        if (nextTab == null) { 
            try {
                Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n << 1];
                nextTab = nt;
            } catch (Throwable ex) {  
                sizeCtl = Integer.MAX_VALUE;
                return;
            }
            nextTable = nextTab;
            transferIndex = n;
        }
        int nextn = nextTab.length;
        ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);
        boolean advance = true;
        boolean finishing = false; 
        //将原数组数据同步到新数组中
        for (int i = 0, bound = 0;;) {
            Node<K,V> f; int fh;
            while (advance) {
                int nextIndex, nextBound;
                if (--i >= bound || finishing)
                    advance = false;
                else if ((nextIndex = transferIndex) <= 0) {
                    i = -1;
                    advance = false;
                }
                //获取线程同步数组信息
                else if (U.compareAndSwapInt
                         (this, TRANSFERINDEX, nextIndex,
                          nextBound = (nextIndex > stride ?
                                       nextIndex - stride : 0))) {
                    bound = nextBound;
                    i = nextIndex - 1;
                    advance = false;
                }
            }
            if (i < 0 || i >= n || i + n >= nextn) {
                int sc;
                if (finishing) {
                    //完成扩容 table 赋值为扩容后的nextTab
                    nextTable = null;
                    table = nextTab;
                    //设置sizeCtl为新的阈值
                    sizeCtl = (n << 1) - (n >>> 1);
                    return;
                }
                // 尝试修改sizeCtl 为sizeCtl 减一
                if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
                    //计算扩容线程数是否超标，扩容线程已满返回
                    if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)
                        return;
                    finishing = advance = true;
                    i = n; 
                }
            }
            //原来位置的Node为null,设置tab该位置Node指向nextTab的Node
            else if ((f = tabAt(tab, i)) == null) 
                advance = casTabAt(tab, i, null, fwd);
            else if ((fh = f.hash) == MOVED) //桶中数据，已经在同步 
                advance = true; 
            else {
                //移动元素到新的数组
                synchronized (f) {
                    if (tabAt(tab, i) == f) {
                        Node<K,V> ln, hn;
                        if (fh >= 0) {
                            int runBit = fh & n;
                            Node<K,V> lastRun = f;
                            for (Node<K,V> p = f.next; p != null; p = p.next) {
                                int b = p.hash & n;
                                if (b != runBit) {
                                    runBit = b;
                                    lastRun = p;
                                }
                            }
                            if (runBit == 0) {
                                ln = lastRun;
                                hn = null;
                            }
                            else {
                                hn = lastRun;
                                ln = null;
                            }
                            for (Node<K,V> p = f; p != lastRun; p = p.next) {
                                int ph = p.hash; K pk = p.key; V pv = p.val;
                                if ((ph & n) == 0)
                                    ln = new Node<K,V>(ph, pk, pv, ln);
                                else
                                    hn = new Node<K,V>(ph, pk, pv, hn);
                            }
                            setTabAt(nextTab, i, ln);
                            setTabAt(nextTab, i + n, hn);
                            setTabAt(tab, i, fwd);
                            advance = true;
                        }
                        else if (f instanceof TreeBin) {
                            TreeBin<K,V> t = (TreeBin<K,V>)f;
                            TreeNode<K,V> lo = null, loTail = null;
                            TreeNode<K,V> hi = null, hiTail = null;
                            int lc = 0, hc = 0;
                            for (Node<K,V> e = t.first; e != null; e = e.next) {
                                int h = e.hash;
                                TreeNode<K,V> p = new TreeNode<K,V>
                                    (h, e.key, e.val, null, null);
                                if ((h & n) == 0) {
                                    if ((p.prev = loTail) == null)
                                        lo = p;
                                    else
                                        loTail.next = p;
                                    loTail = p;
                                    ++lc;
                                }
                                else {
                                    if ((p.prev = hiTail) == null)
                                        hi = p;
                                    else
                                        hiTail.next = p;
                                    hiTail = p;
                                    ++hc;
                                }
                            }
                            ln = (lc <= UNTREEIFY_THRESHOLD) ? untreeify(lo) :
                                (hc != 0) ? new TreeBin<K,V>(lo) : t;
                            hn = (hc <= UNTREEIFY_THRESHOLD) ? untreeify(hi) :
                                (lc != 0) ? new TreeBin<K,V>(hi) : t;
                            setTabAt(nextTab, i, ln);
                            setTabAt(nextTab, i + n, hn);
                            setTabAt(tab, i, fwd);
                            advance = true;
                        }
                    }
                }
            }
        }
    }
3.  treeifyBin 尝试将链表转换成红黑树
//尝试转换树
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)
                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));
                    }
                }
            }
        }
    }
4.  remove 移除元素
public V remove(Object key) {
        return replaceNode(key, null, null);
    }
final V replaceNode(Object key, V value, Object cv) {
        //计算key的hash散列值
        int hash = spread(key.hashCode());
        for (Node<K,V>[] tab = table;;) {
            Node<K,V> f; int n, i, fh;
            // tab为null 或者 tab的长度为0 或者对应hash散列桶是空的 直接跳出循环
            if (tab == null || (n = tab.length) == 0 ||
                (f = tabAt(tab, i = (n - 1) & hash)) == null)
                break;
            //节点的hash为moved 正在扩容，先协助扩容
            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) {
                            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;
    }
5.  底层链表和红黑树结构

                底层链表单向链表

static class Node<K,V> implements Map.Entry<K,V> {
        //KEY的哈希散列值
        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.hash = hash;
            this.key = key;
            this.val = val;
            this.next = next;
        }

        public final K getKey()       { return key; }
        public final V getValue()     { return val; }
        public final int hashCode()   { return key.hashCode() ^ val.hashCode(); }
        public final String toString(){ return key + "=" + val; }
        public final V setValue(V value) {
            throw new UnsupportedOperationException();
        }

        public final boolean equals(Object o) {
            Object k, v, u; Map.Entry<?,?> e;
            return ((o instanceof Map.Entry) &&
                    (k = (e = (Map.Entry<?,?>)o).getKey()) != null &&
                    (v = e.getValue()) != null &&
                    (k == key || k.equals(key)) &&
                    (v == (u = val) || v.equals(u)));
        }
        //
        Node<K,V> find(int h, Object k) {
            Node<K,V> e = this;
            if (k != null) {
                do {
                    K ek;
                    // hash 是否一致，k是否一致 一致返回当前Node
                    if (e.hash == h &&
                        ((ek = e.key) == k || (ek != null && k.equals(ek))))
                        return e;
                } while ((e = e.next) != null);
            }
            return null;
        }
    }

红黑树结构

static final class TreeNode<K,V> extends Node<K,V> {
        //节点父节点数据
        TreeNode<K,V> parent; 
        //子节点左边节点 
        TreeNode<K,V> left;
        //子节点右边节点
        TreeNode<K,V> right;
        TreeNode<K,V> prev; 
        //是否为红色节点   
        boolean red;

        TreeNode(int hash, K key, V val, Node<K,V> next,
                 TreeNode<K,V> parent) {
            super(hash, key, val, next);
            this.parent = parent;
        }

        Node<K,V> find(int h, Object k) {
            return findTreeNode(h, k, null);
        }
        //根据key查找 treeNode
        final TreeNode<K,V> findTreeNode(int h, Object k, Class<?> kc) {
        
            if (k != null) {
                TreeNode<K,V> p = this;
                do  {
                    int ph, dir; K pk; TreeNode<K,V> q;
                    TreeNode<K,V> pl = p.left, pr = p.right;
                    if ((ph = p.hash) > h)
                        p = pl;
                    else if (ph < h)
                        p = pr;
                    else if ((pk = p.key) == k || (pk != null && k.equals(pk)))
                        return p;
                    else if (pl == null)
                        p = pr;
                    else if (pr == null)
                        p = pl;
                    else if ((kc != null ||
                              (kc = comparableClassFor(k)) != null) &&
                             (dir = compareComparables(kc, k, pk)) != 0)
                        p = (dir < 0) ? pl : pr;
                    else if ((q = pr.findTreeNode(h, k, kc)) != null)
                        return q;
                    else
                        p = pl;
                } while (p != null);
            }
            return null;
        }
    }
五、  使用注意事项
1、  线程安全：

                天生就是线程安全的，可以在多线程环境下直接使用，无需额外的同步机制。

2、  高并发性能：

                ConcurrentHashMap 在内部采用了一系列优化措施，如锁分级、乐观锁等，可以支持高并发场景下的读写操作。

3、  初始化容量：

                在创建 ConcurrentHashMap 实例时，可以指定初始容量和负载因子以优化性能。

4、  扩容机制：

                ConcurrentHashMap 在扩容时采用了更为高效的扩容策略，避免了 HashMap 在扩容时的性能问题。

5、  迭代器：

                ConcurrentHashMap 的迭代器是弱一致性的，这意味着如果在迭代过程中其他线程修改了 map，这些修改对于迭代器来说在大多数情况下是不可见的。

6、  键值对的排序：

                ConcurrentHashMap 不保证键值对的顺序，特别是不保证顺序稳定不变。

7、  不支持 null 键和值：

                ConcurrentHashMap 不允许插入 null 键和值。

8、  不支持 fail-fast 机制：

                ConcurrentHashMap 不支持 fail-fast 迭代器，即当迭代器创建后，如果容器被修改，迭代器不会抛出 ConcurrentModificationException，而是在某些情况下忽略这些修改。

六、  总结

                ConcurrentHashmap 相对于Hashmap是线程安全的，但对比hashTable 效率更高，适用与高并发场景，但不支持key或者null为null。

                ConcurrentHashmap 使用分段锁来保证线程安全，每次修改只锁当前的链表，链表也是ConcurretHashmap解决哈希冲突的方式。

标签
#java #开发语言
ConcurrentHashMap介绍
HFUTJungle的博客
07-22 2945
ConcurrentHashMap从JDK1.5开始随java.util.concurrent包一起引入JDK中，主要为了解决HashMap线程不安全和HashTable效率不高的问题。
ConcurrentHashMap：使用方法和底层原理详解
jakelihua
04-07 4499
ConcurrentHashMap是Java集合框架中的一个线程安全的哈希表实现，它提供了比Hashtable和同步的HashMap更高的并发性能。ConcurrentHashMap在JDK 1.5中引入，通过采用分段锁的方式实现了高效的并发访问。它可以在保证线程安全的同时，提供较高的并发性能，因此是多线程环境下使用频率较高的数据结构之一。
ConcurrentHashMap核心原理
最新发布
2301_80321484的博客
05-06 434
本文深入解析JDK1.8中ConcurrentHashMap的线程安全实现机制。其采用数组+链表+红黑树的数据结构，通过CAS+细粒度synchronized实现高效并发控制：空桶采用CAS无锁插入，非空桶仅锁定头节点。putVal()方法支持多线程协助扩容，自动树化；get()方法全程无锁，保证读取性能。这种设计使其成为高并发场景下HashMap的理想替代方案，适用于缓存、共享配置等需要线程安全访问的场景。
翻了ConcurrentHashMap1.7 和1.8的源码，我总结了它们的主要区别。
m0_73311735的博客
09-29 955
Java7 中 ConcurrentHashMap 使用的分段锁，也就是每一个 Segment 上同时只有一个线程可以操作，每一个 Segment 都是一个类似 HashMap 数组的结构，它可以扩容，它的冲突会转化为链表。但是 Segment 的个数一但初始化就不能改变。Java8 中的 ConcurrentHashMap 使用的 Synchronized 锁加 CAS 的机制。结构也由 Java7 中的Segment 数组 + HashEntry 数组 + 链表进化成了。
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
Map 综述（三）：彻头彻尾理解 ConcurrentHashMap
热门推荐
Rico's Blogs
05-27 14万+
ConcurrentHashMap是J.U.C的重要成员，它是HashMap的一个线程安全的版本。在默认理想状态下，ConcurrentHashMap可以支持16个线程执行并发写操作及任意数量线程的读操作。本文将结合Java内存模型和JDK源代码，剖析其高并发的具体实现机制，包括在JDK中的定义和结构、并发存取、重哈希和跨段操作，并着重剖析了ConcurrentHashMap读操作不需要加锁的内在奥秘和原理。
ConcurrentHashMap源码阅读浅析
思考的力量
07-02 333
ConcurrentHashMap源码阅读浅析全局变量和类简介Hash算法Put方法实现数组初始化方法Size计数的方法协助扩容方法核心： 扩容方法 ConcurrentHashMap主体流程与HashMap有很多的相似处，可以先阅读HashMap源码再查看会比较容易理解 全局变量和类简介 //默认的初始化容量 private static final int DEFAULT_CAPACITY = 16; //默认负载因子 private static final float LOAD_FACTOR = 0
ConcurrentHashMap 源码阅读
Kiyra的博客
12-26 1109
Java7 中使用的分段锁，也就是每一个Segment上同时只有一个线程可以操作，每一个Segment都是一个类似HashMap数组的结构，它可以扩容，它的冲突会转化为链表。但是Segment的个数一但初始化就不能改变。Java8 中的使用的锁加 CAS 的机制。结构也由 Java7 中的 Segment数组 +HashEntry数组 + 链表进化成了Node 数组 + 链表 / 红黑树，Node 是类似于一个 HashEntry 的结构。
ConcurrentHashMap源码阅读
duncan891101的专栏
08-05 189
一、ConcurrentHashMap与HashMap、HashTable的区别 1.HashMap 我们知道HashMap是线程不安全的，在多线程环境下，使用HashMap进行put操作有可能引起数据丢失，也有可能因为扩容而导致CPU利用率接近100%，所以在并发情况下不能使用HashMap。 2.HashTable Hashtable和HashMap的实现原理几乎一样，差别无非是 （1）HashTable不允许key和value为null，而HashMap可以 （2）HashTable是线程安全的，Ha
源码阅读系列-ConcurrentHashMap
普普通通程序猿的博客
11-09 336
注释 注释是代码作者最想留给读者的话，我们真的应该好好读一读。 从线程安全的角度来讲，ConcurrentHashMap与Hashtable是可以互用的，但是从同步机制上二者是有一些区别的。 ConcurrentHashMap并不对并发读取操作上锁，读写操作有可能会同时进行。一些方法诸如size/isEmpty/containsValue反映的是某一个临时状态，因此如果有另外的线程在并发写的时候是不太适合使用的。 ...
ConcurrentHashmap源码阅读
星星源之心
11-19 472
ConcurrentHashmap源码
ConcurrentHashMap源码阅读笔记
xxy_hl的博客
08-02 244
上一篇文章中对HashMap的源码进行了简单的学习，但是HashMap在多线程的环境下会存在线程安全问题。所以呢这篇文章主要对ConcurrentHashMap的源码进行学习，了解一下ConcurrentHashMap是如何保证线程安全的。 HashMap源码阅读笔记：https://blog.csdn.net/xxy_hl/article/details/91947452 ConcurrentH...
ConcurrentHashMap源码阅读总结
y152543654的博客
04-12 350
容器复习笔记 本文结合优秀博客，jdk 源码，在源码上进行逐行注释，全面整体分析 hashmap1.7，1.8，以及ConcurrentHashMap 1.7，1.8，给出其代码的框图已经整体的代码流程总结，在最后还会结合大厂真实面试题进行总结，对比1.7，1.8版本的区别，一文打通容器，秒杀面试官,总体目录如下 文章目录4. java7 ConcurrentHashMap4.1 基本属性以及整体结构4.2 初始化4.3 put 过程4.3.1 定位 segment4.3.2 定位 segment 内部
ConcurrentHashMap源码阅读02
js_tengzi的博客
10-16 338
在上一篇我们介绍了ConcurrentHashMap的常量、存储单元及成员变量。今天我们就结合测试案例来探究一下ConcurrentHashMap中put方法的实现原理。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值