并发编程之ConcurrentHashMap源码解析（一）

最新推荐文章于 2023-04-08 18:19:36 发布
最新推荐文章于 2023-04-08 18:19:36 发布
阅读量859 收藏
点赞数 1
分类专栏： 并发编程 文章标签： java hashmap
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhao6406879/article/details/113264931
版权

ConcurrentHashMap简介

ConcurrentHashMap是java中并发安全的HashMap，HashMap是我们最常使用的容器，但HashMap是不安全的。在多线程情况下，需使用ConcurrentHashMap。ConcurrentHashMap在jdk1.7底层使用Segment实现分段锁，ConcurrentHashMap底层是Segment数组，而每个Segment对象下面是个小型的HashMap。Segment对象继承ReentrantLock，操作时通过ReentrantLock来实现锁操作。
jdk1.8后，ConcurrentHashMap底层和HashMap相同，数组+链表/红黑树，而缩小锁力度，使用synchronized关键字锁数组的元素来实现锁操作。

ConcurrentHashMap源码

put方法

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

直接调用putVal方法

final V putVal(K key, V value, boolean onlyIfAbsent) {
        if (key == null || value == null) throw new NullPointerException();
        //根据key算出hash值
        int hash = spread(key.hashCode());
        int binCount = 0;
        //自旋，直到put成功
        for (Node<K,V>[] tab = table;;) {
            Node<K,V> f; int n, i, fh;
            //数组为空，初始化数组
            if (tab == null || (n = tab.length) == 0)
                tab = initTable();
            //根据hash值算出数组下标，数组中取出Node对象
            else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
            	//为空new Node后cas设置到下标位置
            	//cas成功直接break，失败自旋再次cas
                if (casTabAt(tab, i, null,
                             new Node<K,V>(hash, key, value, null)))
                    break;                   
            }
            //table[i]的Node的hash为-1
            //表示整个ConcurrentHashMap在扩容（某一个或多个线程正在扩容）
            else if ((fh = f.hash) == MOVED)
            	//帮助线程扩容（扩容操作下章详细讲解）
                tab = helpTransfer(tab, f);
            else {
            	//根据下标已经找出Node，判断Node是链表还是红黑树，替换值
                V oldVal = null;
                //若为链表，则对链表第一个节点上锁
                //若未红黑树，则对整个红黑树对象TreeBin上锁，因为红黑树的根节点root会变化
                synchronized (f) {
                	//判断f是否为头节点，防止加锁过程中别的线程操作
                    if (tabAt(tab, i) == f) {
                     	//判断hash值 >= 0，表示链表，否则为红黑树
                        if (fh >= 0) {
                            binCount = 1;
                            //循环链表
                            for (Node<K,V> e = f;; ++binCount) {
                                K ek;
                                //比较hash和key，相同设置值为value
                                if (e.hash == hash &&
                                    ((ek = e.key) == key ||
                                     (ek != null && key.equals(ek)))) {
                                    oldVal = e.val;
                                    if (!onlyIfAbsent)
                                        e.val = value;
                                    break;
                                }
                                 //遍历到最后，还没有相同的，则新增Node，插入到最后
                                //尾插法
                                Node<K,V> pred = e;
                                if ((e = e.next) == null) {
                                    pred.next = new Node<K,V>(hash, key,
                                                              value, null);
                                    break;
                                }
                            }
                        }
                         //为TreeBin，代表为红黑树
                        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;
                            }
                        }
                    }
                }
                //put链表 binCount = 1，随着链表循环++，即链表数量
                //put红黑树 binCount = 2
                if (binCount != 0) {
                	//判断binCount大于默认8，则树化
                    if (binCount >= TREEIFY_THRESHOLD)
                        treeifyBin(tab, i);
                    //返回oldVal
                    if (oldVal != null)
                        return oldVal;
                    //跳出循环
                    break;
                }
            }
        }
        //先对size+1，大于阈值扩容
        addCount(1L, binCount);
        return null;
    }

总结下过程：
1、算出hash值
2、数组未初始化先初始化数组
3、根据hash值算出数组下标，节点为空直接新建Node赋值
4、数组正在扩容，帮助扩容
5、Node节点不为空，上锁
6、若为链表，循环链表，存在替换，不存在新建Node插入尾部
7、若为红黑树，插入树中
8、插入成功判断是否需要树化，链表转红黑树
9、替换旧值直接返回旧值
10、新增，ConcurrentHashMap容量+1，判断是否需要扩容，需要执行扩容操作

initTable初始化容器

    private final Node<K,V>[] initTable() {
        Node<K,V>[] tab; int sc;
        //自旋
        while ((tab = table) == null || tab.length == 0) {
            //sizeCtl初始为0
            if ((sc = sizeCtl) < 0)
                Thread.yield(); // lost initialization race; just spin
            //cas设置sizeCtl为-1 ，变向加锁，只有一个线程可以设置成功
            //其他线程false，再次循环进去第一个if，执行Thread.yield()，让出CPU时间片
            else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
                try {
                    if ((tab = table) == null || tab.length == 0) {
                        //默认大小16
                        int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
                        //新建Node<K,V>[]
                        Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
                        table = tab = nt;
                        //设置sc为数组大小的0.75
                        sc = n - (n >>> 2);
                    }
                } finally {
                    sizeCtl = sc;
                }
                break;
            }
        }
        return tab;
    }

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;
                        }
                        //hd为链表首节点，传入TreeBin的构造方法中
                        //数组对应的Node节点为TreeBin，整个红黑树对象
                        setTabAt(tab, index, new TreeBin<K,V>(hd));
                    }
                }
            }
        }
    }

size 容器大小

    public int size() {
    	//计算出大小
        long n = sumCount();
        //校验大小值，是否在0 - 最大值 区间
        return ((n < 0L) ? 0 :
                (n > (long)Integer.MAX_VALUE) ? Integer.MAX_VALUE :
                (int)n);
    }

调用sumCount统计大小，看源码

    final long sumCount() {
        CounterCell[] as = counterCells; CounterCell a;
        long sum = baseCount;
        if (as != null) {
        	//以baseCount为基础，累加所有CounterCell数组上的value值
            for (int i = 0; i < as.length; ++i) {
                if ((a = as[i]) != null)
                    sum += a.value;
            }
        }
        return sum;
    }

如下图，先说明下ConcurrentHashMap统计
在这里插入图片描述
为了保证统计大小的多编程效率，采用baseCount+CounterCell[]来统计大小，线程put成功addCount 时可以baseCount+1，也可以随机取一个CounterCell，value值+1。
统计容器大小时，以baseCount为基础，累加所有CounterCell数组上的value值，最后得出容器大小。

addCount 修改容器大小

    //remove时 x = -1
    //put时 x = 1
    //put时	链表 check = 链表长度
    //put时	红黑树 check =2
    private final void addCount(long x, int check) {
        CounterCell[] as; long b, s;
        //所有线程cas竞争baseCount, baseCount+1成功设置，不成功进入if逻辑
        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 ||
                    //ThreadLocalRandom.getProbe() & m
                    //随机数 & CounterCell[].length 随机获取CounterCell[]下标
                    //CounterCell a为CounterCell[]随机一个
                    //cas 对CounterCell中value+1
                    // 失败进去fullAddCount方法
                    (a = as[ThreadLocalRandom.getProbe() & m]) == null ||
                    !(uncontended =
                            U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))) {
                //as == null
                //as.length == 0
                //CounterCell[随机数] 为空
                //CounterCell[随机数] 不为空cas value失败
                //上述4中情况进去
                fullAddCount(x, uncontended);
                return;
            }
            if (check <= 1)
                return;
            s = sumCount();
        }
        if (check >= 0) {
            Node<K,V>[] tab, nt; int n, sc;
            //扩容操作，下一章节细说
            //sizeCtl 0.75 * 数组长度 且table不为null 且 table长度小于最大值
            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);
                }
                //(rs << RESIZE_STAMP_SHIFT) + 2) 为负数
                else if (U.compareAndSwapInt(this, SIZECTL, sc,
                        (rs << RESIZE_STAMP_SHIFT) + 2))
                    transfer(tab, null);
                s = sumCount();
            }
        }
    }

总结下addCount步骤：
1、所有线程cas竞争baseCount，成功设置+1
2、失败则会找到CounterCell数组下标，cas设置value+1
3、其他情况下会调用fullAddCount，情况见注解

fullAddCount写入大小

fullAddCount为本章节最难代码，希望我的注解和总结能帮你看懂

private final void fullAddCount(long x, boolean wasUncontended) {
        int h;
        //ThreadLocalRandom.getProbe() 线程随机数，每个线程对应一个数，每次都一样
        //为0则初始化getProbe，然后重新获取
        if ((h = ThreadLocalRandom.getProbe()) == 0) {
            ThreadLocalRandom.localInit(); 
            h = ThreadLocalRandom.getProbe();
            wasUncontended = true;
        }
        boolean collide = false;               
        for (;;) {
            CounterCell[] as; CounterCell a; int n; long v;
            //判断counterCells数组不为null且大于0
            if ((as = counterCells) != null && (n = as.length) > 0) {
                //(n - 1) & h 根据h值算出下标，判断此下标对应的CounterCell为null
                if ((a = as[(n - 1) & h]) == null) {
                    //对应的CounterCell为null，先判断cellsBusy为0表示没有线程使用
                    if (cellsBusy == 0) {
                        //新建CounterCell对象
                        CounterCell r = new CounterCell(x);
                        //再次判断数组是否有线程使用未使用cas设置 
                        //cellsBusy 为1，表示数组使用中
                        if (cellsBusy == 0 &&
                                U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
                            boolean created = false;
                            try {
                                CounterCell[] rs; int m, j;
                                //判断counterCells数组已初始化且 h对应的下标的CounterCell为null
                                //则赋值new的CounterCell，created为true
                                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;      
                        }
                    }
                    //别的线程操作数组collide改为fasle
                    collide = false;
                }
                //addCount中进来时wasUncontended为false
                //修改成true，走ThreadLocalRandom.advanceProbe(h)生成新值
                //意思设置ACounterCell失败，则改变hash，试着设置其他CounterCell
                else if (!wasUncontended)
                    wasUncontended = true;
                //cas设置线程对应的CounterCell的value+1，成功break
                else if (U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))
                    break;
                //数组发生变化或者 数组长度 >= CPUS，则不再扩容
                else if (counterCells != as || n >= NCPU)
                    collide = false;      
                else if (!collide)
                    collide = true;
                // collide = true 进入，表示扩容
                else if (cellsBusy == 0 &&
                        U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
                    try {
                        if (counterCells == as) {
                            //new CounterCell[]，大小是之前2倍
                            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; 
                }
                //ThreadLocalRandom.getProbe()生成新值，否则生成的值相同
                h = ThreadLocalRandom.advanceProbe(h);
            }
            //cellsBusy表示是否有其他线程使用，0表示没有
            //cas设置 CELLSBUSY 为 1，表示有线程使用数组
            else if (cellsBusy == 0 && counterCells == as &&
                    U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
                boolean init = false;
                try {
                    // 判断counterCells是否有改变，还是之前的则初始化
                    if (counterCells == as) {
                        //初始化CounterCell数组，大小为2
                        CounterCell[] rs = new CounterCell[2];
                        //CounterCell[h & 1]]赋值为CounterCell(1)
                        //h & 1 为 0 或 1
                        rs[h & 1] = new CounterCell(x);
                        counterCells = rs;
                        init = true;
                    }
                } finally {
                    //表示线程用完了
                    cellsBusy = 0;
                }
                //初始化成功break
                if (init)
                    break;
            }
            //两个线程同时进来，这是CounterCell[]为空
            //一个线程初始化CounterCell[]，还有一个线程cas设置baseCount
            else if (U.compareAndSwapLong(this, BASECOUNT, v = baseCount, v + x))
                break;                         
        }
    }

虽然每行代码都有注解，但在一起就看不懂了。的确很复杂，我们来总结下过程。

    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)) {
        }
        else if (U.compareAndSwapLong(this, BASECOUNT, v = baseCount, v + x))
            break;
    }

我们看自旋中最外层3个判断
1、CounterCell数组长度大于0，则操作CounterCell数组，取线程对应CounterCell的value+1
2、cellsBusy为0表示无线程操作，设置cellsBusy为1，初始化CounterCell数组
3、多线程同时进来时，有的线程操作CounterCell数组，有的线程操作baseCount+1

总结下步骤：
1、第一次进来CounterCell数组未初始化，进入第二个if，cas设置cellsBusy为1，初始化大小为2的CounterCell数组，根据hash设置数组0或1位置为value=传入x的CounterCell对象，cas设置cellsBusy为0，退出
2、若多线程同时进入第二个if，只有一个线程会cas设置cellsBusy成功，其他线程进入第三个if，cas修改baseCount值
3、接下来有线程进来，此时CounterCell已初始化，进入第一个if
3.1 根据h值算出下标，若此下标对应的CounterCell为null，新建value=传入x的CounterCell对象，cas设置cellsBusy为0成功，赋值给线程对应下标的CounterCell，cas设置cellsBusy为0，退出
3.2 下标对应的CounterCell不为nul，cas设置value+1，成功退出
3.3 cas竞争失败，重新生成线程新值，即改变线程对应的CounterCell元素，继续循环走
3.1 -》.3.2 -》3.3逻辑
3.4 若仍失败，表示竞争线程较多，CounterCell数组较小，竞争较大，会扩容CounterCell数组，大小是之前2倍，迁移旧的数组value至新数组
3.5 继续循环走3.1 -》.3.2 -》3.3逻辑，成功退出，失败继续扩容，直到 数组长度 >= CPU数量，则不再扩容

get方法

public V get(Object key) {
        Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
        //计算hash
        int h = spread(key.hashCode());
        //table存在，找出key对象下标的Node节点
        //table不存在或者对应的Node不存在返回null
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (e = tabAt(tab, (n - 1) & h)) != null) {
            //hash值相同，表示table对应下标只有一个元素，比较key值相同返回值
            if ((eh = e.hash) == h) {
                if ((ek = e.key) == key || (ek != null && key.equals(ek)))
                    return e.val;
            }
            //红黑树中查询值
            else if (eh < 0)
                return (p = e.find(h, key)) != null ? p.val : null;
            //链表中循环找出key相同值
            while ((e = e.next) != null) {
                if (e.hash == h &&
                    ((ek = e.key) == key || (ek != null && key.equals(ek))))
                    return e.val;
            }
        }
        return null;
    }

get方法就比较简单，参考注释一眼看懂。

后话

ConcurrentHashMap真的很复杂，需要慢慢品，下一章节带来扩容内容，更加复杂。上面内容是自己看源码的心得，也可能哪边有理解错误的地方，望指正。

小小小金鱼
关注
专栏目录
Java源码解析ConcurrentHashMap的初始化
08-26
在Java并发编程中，ConcurrentHashMap是一个非常重要的数据结构，它可以在多线程环境下提供高效的哈希表操作。今天，我们将深入探讨ConcurrentHashMap的初始化过程，并分析其多线程间的同步机制。 首先，看一下...
ThreadLocalRandom#getProbe #advanceProbe浅析
anlian523的博客
07-12 2506
简单的说，一个线程的probe探针值，是一个hash值，它不会和其他线程重复（一定情况下）。 ThreadLocalRandom的probe机制在线程数比较少，且probe移动次数也比较小时，是可以保证探针不重复的。 但是不重复的情况指的是在int的范围内不重复，在有限的桶位面前，由于只取probe值的后几位bit，那么很大概率也会重复。
进阶学习之旅-多线程之深入concurrentHashMap
种一颗十年前的树
09-14 371
文章目录学习内容不同版本区别基本的数据结构put的实现过程源码分析源码中位运算巧妙的应用初始化tab以及sizeCtl的作用初始化tabsizeCtl的作用addCount是做什么的？CounterCell为什么基于CounterCell来计算容器大小？扩容扩容源码分析将当前的链表分为高低链，提高扩容的效率为什么可以提高扩容的效率?学习内容总结 学习内容 put的实现过程 不同版本区别 源码分析 为什么使用CounterCell来计算容器大小？ 学习内容总结 不同版本区别 HashMap？Concurr
JDK1.8中ConcurrentHashMap全源码解读（初始化机制、自动扩容机制、Put方法）
最新发布
Strine的博客
04-08 527
JDK1.8ConcurrentHashMap全源码分析，Put方法分析，锁机制的分析，扩容机制分析，初始化机制分析，1.7和1.8ConcurrentHashMap的对比
并发包中ThreadLocalRandom类原理剖析
技术原始积累
12-24 507
2.2 并发包中ThreadLocalRandom类原理剖析ThreadLocalRandom类是JDK7在JUC包下新增的随机数生成器，它解决了Random类在多线程下...
关于 ConcurrentHashMap 1.8 中的线程探针哈希
L__ear的博客
06-03 2441
ConcurrentHashMap 在累加键值对个数的 addCount 函数中，使用 ThreadLocalRandom.getProbe() 得到线程的探针哈希值。 在这里，这个探针哈希值的作用是哈希线程，将线程和数组中的不用元素对应起来，尽量避免线程争用同一数组元素。探针哈希值和 map 里使用的哈希值的区别是，当线程发生数组元素争用后，可以改变线程的探针哈希值，让线程去使用另一个数组元素，而 map 中 key 对象的哈希值，由于有定位 value 的需求，所以它是一定不能变的。 那么这个探针哈希值
ConcurrentHashMap源码解析
01-17
在Java并发编程中，ConcurrentHashMap是一个重要的并发集合。它是由Doug Lea在JSR166y中引入，并在Java 5中提供的一种线程安全的HashMap实现。与传统的HashMap相比，ConcurrentHashMap在多线程环境下具有更好的性能...
java并发编程源码
02-22
这里主要围绕"并发"和"源码"这两个关键标签，详细讲解Java并发编程的核心知识点，并结合提供的压缩包文件名来解析可能涉及的内容。 首先，Java并发编程是Java程序设计中的重要组成部分，它涉及到如何让多个任务在...
并发编程之一 日常学习笔记
10-26
首先，"并发编程之深入理解JMM&并发三大特性"，这里的JMM指的是Java内存模型（Java Memory Model），它是Java平台中的核心概念，用于规定了线程之间如何共享和访问内存中的数据。并发的三大特性包括原子性、可见性和...
线程基础：多任务处理（15）——Fork/Join框架（要点2）
05-31 248
========（接上文《线程基础：多任务处理（14）——Fork/Join框架（要点1）》） 2-3. ForkJo...
java8 ConcurrentHashMap源码&原理解读，保姆级解读，并行/并发编程思想
yygr的博客
03-31 1541
https://blog.csdn.net/qq_29031555/article/details/105907234 前言 之前研读过HashMap源码,实现过一遍HashMap源码。但是HashMap是线程不安全的，而ConcurrentHashMap是线程安全的，博主我觉得自己多线程方面差了点，遂决定去研究一番ConcurrentHashMap。这一看，emmm，妙呀，有时一个方法起码得研究好几天，打开一篇知识的海洋。笔者去年终于看完整个put方法的处理，〒▽〒，实现到扩容那里了。后面由于换工
java多线程与并发原理学习笔记（四）———ConcurrentHashMap原理
飞！！！的博客
02-24 849
ConcurrentHashMap原理
并发编程（十二）：ConcurrentHashMap源码分析
zp_zhang的博客
10-07 246
一，ConcurrentHashMap概述 1，ConcurrentHashMap * ConcurrentHashMap 和 HashMap 原理基本一致，就是在 HashMap 的基础上增加了锁处理，支持并发操作，在实现上比 HashMap 更复杂点。先比较与 JDK7，JDK8在实现上，修改原来通过 Segment 进行加锁的方式改为通过 Node 进行加锁，同时在链表方面，如果...
ConcurrentHashMap总结
weixin_33881050的博客
05-16 4028
为什么80%的码农都做不了架构师？>>> ...
高并发情况下你还在用Random生成随机数?
热门推荐
敖丙
04-06 2万+
不是吧，阿sir
Java并发编程-34-生成并发随机数-ThreadLocalRandom
我自倾怀，君且随意
06-21 4334
一、ThreadLocalRandom 这是一个线程本地变量，每个生成随机数的线程都有一个不同的生成器，但是都在同一个类中被管理。 current()方法：这是一个静态方法，返回与当前线程关联的TaskLocalRandom对象，所以可以使用这个对象生成随机数 public static ThreadLocalRandom current() { if (
JDK1.8逐字逐句带你理解ConcurrentHashMap(3)
brickworkers的博客
03-30 5151
引言这篇是介绍ConcurrentHashMap的第三篇，第一篇主要介绍了在jdk1.8中所用到的一些关键知识点，第二篇主要学习了ConcurrentHashMap的组织结构与线程安全的实现，同时介绍了几个极其重要的内部类。这一篇主要是我学习领悟到的几个核心方法，包括扩容，添加和查找。笔者目前整理的一些blog针对面试都是超高频出现的。大家可以点击链接：http://blog.csdn.net/u0
ConcurrentHashMap 总结（ 下 ）
zl15145428的博客
09-22 264
来源：Hosee， my.oschina.net/hosee/blog/675884 2.8 Size相关的方法 对于ConcurrentHashMap来说，这个table里到底装了多少东西其实是个不确定的数量，因为不可能在调用size()方法的时候像GC的“stop the world”一样让其他线程都停下来让你去统计，因此只能说这个数量是个估计值。对于这个
Java并发29:ThreadLocalRandom学习笔记-随机数的三种使用方法
韩超的博客 (hanchao5272)
03-25 3517
[超级链接：Java并发学习系列-绪论] 本章主要对ThreadLocalRandom进行学习。 1.ThreadLocalRandom简介 ThreadLocalRandom是Java提供的用于并发产生伪随机数的工具类，出现于JDK1.7版本中。 ThreadLocalRandom可以看做Math.random()的并发升级类。 ThreadLocalRandom不是直接用ne...
Java并发编程：深度解析ConcurrentHashMap源码
"分析Java中的ConcurrentHashMap源码" 在Java编程语言中，`ConcurrentHashMap`是一个线程安全的哈希表，它提供了与`HashTable`类似的功能，但其设计使得在多线程环境下的性能更优。`ConcurrentHashMap`的主要特点是...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值