ConcurrentHashMap

已于 2023-05-06 10:27:07 修改
阅读量1.5k 收藏 2
点赞数 2
分类专栏： 多线程 面试题 文章标签： 数据结构 链表 java
于 2023-03-28 10:04:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Zyw907155124/article/details/129810037
版权

文章目录

一、ConcurrentHashMap在1.8做了哪些优化？

在这里插入图片描述

1.1 存储结构

  • JDK1.8中是以CAS+synchronized实现的线程安全
  • CAS：在没有hash冲突时（Node要放在数组上时）
  • synchronized：出现hash冲突时（Node存放的位置已经有数据了）
  • 存储结构：数组+链表+红黑树
  • 出现hash冲突后，数据会挂在链表上，此时查询的时间复杂度为(O)n，链表长度过长时，查询效率过低。
  • 因此1.8后引入红黑树
  • 当里链表长度大于8，数组长度大于等于64时，将链表转为红黑树，(O)logn

在这里插入图片描述

1.2 存储操作

锁头结点：锁的粒度增大

数据放在数组上时，用CAS；

数据放在链表上，用synchronized，操作哪个节点，只锁对应的节点，因此数组长度有多少，锁的级别就有多少

1.3 扩容

//链表长度大于等于8时，尝试将链表转为红黑树
private final void treeifyBin(Node<K,V>[] tab, int index) {
        Node<K,V> b; int n, sc;
    //数组不能为空
        if (tab != null) {
            //数组的长度n，是否小于64
            if ((n = tab.length) < MIN_TREEIFY_CAPACITY)
                //如果数组长度小于64，不能将链表转为红黑树，先尝试扩容
                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));
                    }
                }
            }
        }
    }

1.4 计数器

计数器由AtomicLong换成类似于LongAdder的一个功能

1.4.1 AtomicLong：

基于CAS操作实现，并发较高情况下，多个现场同时CAS，只会有一个成功，没有成功的线程会一直执行CAS直到成功为止。

1.4.2 LongAdder：

如果并发执行自增操作时，CAS失败了，会将数据单独存储在一个数组中计数。

二、ConcurrentHashMap的散列算法？

目的，原本只有低位参与了运算，通过散列算法尽量打撒我的数据，将key的hashCode值的高16位进行^运算，最终又与HASH_BITS进行&运算，尽量平均的分摊到真个map的存储上。

final V putVal(K key, V value, boolean onlyIfAbsent) {
    //ConcurrentHashMap不允许key或者value出现null值
        if (key == null || value == null) throw new NullPointerException();
    //根据key的hashCode计算出一个hash值，后期得出当前key-value要存储在哪个数组索引位置
        int hash = spread(key.hashCode());
    //一个标识
        int binCount = 0;
        for (Node<K,V>[] tab = table;;) {
            //n:数组长度
            //i:当前索引的位置
            //f:当前数组i索引位置的Node对象
            //fn:当前数组i索引位置上数据的hash值
            Node<K,V> f; int n, i, fh;
            //判断当前数组是否还没有初始化
            if (tab == null || (n = tab.length) == 0)
                //将数组进行初始化
                tab = initTable();
            //基于(n-1) & hash 计算出当前Node需要存放在哪个索引位置
            //基于tabAt获取到i位置的数据
            else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
                //现在数组的i位置上没有数据，基于CAS的方式将数据存放在i上
                if (casTabAt(tab, i, null,
                             new Node<K,V>(hash, key, value, null)))
                    //如果成功，执行break跳出循环，插入数据成功
                    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;
    }

    static final int HASH_BITS = 0x7fffffff;  
//计算当前Node的hash值的方法    
static final int spread(int h) {
        //将key的hashCode值的高16位进行^运算，最终又与HASH_BITS进行&运算
        //将最高位的hash也参与到计算索引位置的运算中
        //为什么HashMap、ConcurrentHashMap都要求数组长度为2^n
    //HASH_BITS让hash值的最高位符号位肯定为0，代表当前hash值默认情况下一定为正数，因为hash值为负数时，有特殊的含义
    //static final int MOVED     = -1; // 代表当前hash位置的数据正在扩容！
    //static final int TREEBIN   = -2; // 代表当前hash位置下挂载的是一个红黑树
    //static final int RESERVED  = -3; // 预留当前索引位置
        return (h ^ (h >>> 16)) & HASH_BITS;
    //计算数组放在哪个索引位置的方法（f = tabAt(tab, i = (n-1) & hash)）
    //n 是数组的长度
    }

三、ConcurrentHashMap初始化数组的流程？

懒加载：第一次添加数据时，才会初始化数组。

//数组在初始化和扩容操作时的一个控制变量
//-1：代表当前数组正在初始化
//小于-1：低16位代表当前数组正在扩容的线程个数（如果1个线程扩容，值为-2；如果2个线程扩容，值为-3）
//0：代表数组还没初始化
//大于0：代表当前数组的扩容阈值，或者是当前数组的初始化大小
private transient volatile int sizeCtl;
//初始化数组方法
private final Node<K,V>[] initTable() {
    //声明标识
    Node<K,V>[] tab; int sc;
    //再次判断数组没有初始化，并且完成tab赋值    
    while ((tab = table) == null || tab.length == 0) {
        //将sizeCtl赋值给sc变量，并判断是否小于0
            if ((sc = sizeCtl) < 0)
                Thread.yield(); 
        // 可以尝试初始化数组，线程会以CAS的方式，将sizeCtl修改为-1，代表当前线程可以初始化数组
            else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
                //尝试初始化
                try {
                    //再次判断当前数组是否已经初始化完毕
                    if ((tab = table) == null || tab.length == 0) {
                        //开始初始化
                        //如果sizeCtl > 0 ，就初始化sizeCtl长度的数组
                        //如果sizeCtl ==0 ，就初始化默认的长度
                        int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
                        //初始化数组！
                        @SuppressWarnings("unchecked")
                        Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
                        //将初始化的数组nt，赋值给tab和table
                        table = tab = nt;
                        //sc赋值为了数组长度 - 数组长度 右移 2位  16-4=12
                        //将sc赋值为下次扩容的阈值
                        sc = n - (n >>> 2);
                    }
                } finally {
                    //将赋值好的sc，设置给sizeCtl
                    sizeCtl = sc;
                }
                break;
            }
        }
        return tab;
    }

四、ConcurrentHashMap扩容的流程？

  • 确认什么时候触发扩容
  • 计算扩容标识戳
  • 将扩容表示戳往左移16位+2（代表第一个进来扩容的）
  • 计算每个线程迁移的长度
  • 初始化一个全新的数组
  • 线程领取任务，从多少索引位置迁移到多少索引位置
  • 开始扩容、迁移数据
  • 判断是否为最后一个完成迁移的
  • 如果是则全局检查一次有没有遗漏的数据
   //链表长度大于等于8时，尝试将链表转为红黑树
private final void treeifyBin(Node<K,V>[] tab, int index) {
        Node<K,V> b; int n, sc;
    //数组不能为空
        if (tab != null) {
            //数组的长度n，是否小于64
            if ((n = tab.length) < MIN_TREEIFY_CAPACITY)
                //如果数组长度小于64，不能将链表转为红黑树，先尝试扩容
                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.2 tryPresize方法-针对putAll初始化操作

//size是将之前的数组长度 左移1位得到的结果
private final void tryPresize(int size) {
    //如果扩容的长度达到了最大值，就使用最大值
    //否则需要保证数组的长度为2的n次幂
    //这块的操作，是为了初始化操作准备的，因为调用putAll方法时，也会触发tryPresize方法
    //如果刚刚new的ConcurrentHashMap直接调用饿了putAll方法，会通过tryPresize方法进行初始化
        int c = (size >= (MAXIMUM_CAPACITY >>> 1)) ? MAXIMUM_CAPACITY :
            tableSizeFor(size + (size >>> 1) + 1);
    //这些代码和initTable一模一样
    //声明sc
        int sc;
    //将sizeCtl的值赋给sc，并且判断是否大于0，这里代表没有初始化操作，也没有扩容操作
        while ((sc = sizeCtl) >= 0) {
            //将ConcurrentHashMap的table值赋值给tab，并声明数组长度n
            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;
                    }
                }
            }
            else if (c <= sc || n >= MAXIMUM_CAPACITY)
                break;
            else if (tab == table) {
                //计算扩容表示戳，根据当前数组的长度计算一个16位的扩容戳
                //第一个作用是为了保证后面的sizeCtl赋值时，保证sizeCtl为小于-1的负数
                //第二个作用用来记录当前是从什么长度开始扩容的
                int rs = resizeStamp(n);
                //如果sc小于0，代表有线程正在扩容
                if (sc < 0) {
                    Node<K,V>[] nt;
                    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);
            }
        }
    }

4.3 transfer方法计算每个线程迁移的长度

//开始扩容    
private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
        //n = 数组长度
    //stride = 每个线程一次性迁移多少数据到新数组
        int n = tab.length, stride;
    //基于CPU内核数组来计算，每个线程一次性迁移多少长度的数据最合理
    //NCPU=4
    //例：数组长度为1024 - 512 - 256 - 128  / 4 = 32 
    //MIN_TRANSFER_STRIDE = 16，为每个线程迁移数据的最小长度
        if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
            stride = MIN_TRANSFER_STRIDE; 
    // 根据CPU计算每个线程一次迁移多长的数据到新数组，如果结果大于16，使用计算结果；
    //如果小于16，就使用最小长度。

    }

五、ConcurrentHashMap读取数据的流程？

  • 不会阻塞读取数据的线程。
  • 先判断当前key对应的value，是否在数组上。
  • 其次判断当前位置是否属于特殊情况：数据被迁移、位置被占用、红黑树结构。
  • 最后判断链表上是否有对应的数据。

5.1 get方法-查询数据的入口

    public V get(Object key) {
        //tab：数组；e：查询指定位置的节点；n：数组长度
        Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
        //基于传入的key，计算hash值
        int h = spread(key.hashCode());
        //数组不为null，数组得有数据，拿到指定位置的数组上的数据
        if ((tab = table) != null && (n = tab.length) > 0 && (e = tabAt(tab, (n - 1) & h)) != null) {
            //数组上数据的hash值，是否和查询条件key的hash值一样
            if ((eh = e.hash) == h) {
                //key的==或者equals是否一致，一致则数组上就是要查询的数据
                if ((ek = e.key) == key || (ek != null && key.equals(ek)))
                    return e.val;
            }
            //如果数组上的数据的hash值为负数，有特殊情况
            else if (eh < 0)
                //三种情况：数据迁移、节点位置被占、红黑树结构
                return (p = e.find(h, key)) != null ? p.val : null;
            //肯定走链表操作
            while ((e = e.next) != null) {
                //如果hash值一致，并且key的==或者equals一致，返回当前链表位置的数据
                if (e.hash == h &&
                    ((ek = e.key) == key || (ek != null && key.equals(ek))))
                    return e.val;
            }
        }
        //如果上述三个流程都没有找到指定key对应的value，那就是key不存在，返回null
        return null;
    }

数据迁移：

Node<K,V> find(int h, Object k) {
            //找到迁移后的新数组
            outer: for (Node<K,V>[] tab = nextTable;;) {
                Node<K,V> e; int n;
                if (k == null || tab == null || (n = tab.length) == 0 ||
                    (e = tabAt(tab, (n - 1) & h)) == null)
                    return null;
                for (;;) {
                    int eh; K ek;
                    if ((eh = e.hash) == h &&
                        ((ek = e.key) == k || (ek != null && k.equals(ek))))
                        return e;
                    if (eh < 0) {
                        if (e instanceof ForwardingNode) {
                            tab = ((ForwardingNode<K,V>)e).nextTable;
                            continue outer;
                        }
                        else
                            return e.find(h, k);
                    }
                    if ((e = e.next) == null)
                        return null;
                }
            }
        }

红黑树：

        final Node<K,V> find(int h, Object k) {
            if (k != null) {
                for (Node<K,V> e = first; e != null; ) {
                    int s; K ek;
                    //判断你是否正在有写的操作或者有写的操作在等待
                    //查询转换红黑树时保留的双向链表
                    if (((s = lockState) & (WAITER|WRITER)) != 0) {
                        if (e.hash == h &&
                            ((ek = e.key) == k || (ek != null && k.equals(ek))))
                            return e;
                        e = e.next;
                    }
                    //如果已经没有写操作在进行了，直接去红黑树上查找
                    else if (U.compareAndSwapInt(this, LOCKSTATE, s,
                                                 s + READER)) {
                        TreeNode<K,V> r, p;
                        try {
                            p = ((r = root) == null ? null :
                                 r.findTreeNode(h, k, null));
                        } finally {
                            Thread w;
                            if (U.getAndAddInt(this, LOCKSTATE, -READER) ==
                                (READER|WAITER) && (w = waiter) != null)
                                LockSupport.unpark(w);
                        }
                        return p;
                    }
                }
            }
            return null;
        }

六、ConcurrentHashMap中计数器的实现

  • addCount方法中：记录Map中存储了多少个元素
  • 为防止效率过低，
  • 除了baseCount之外，还准备了多个CounterCell数组，
  • 最后将baseCount的值以及每个CounterCell数组中值进行累加
    private final void addCount(long x, int check) {
        CounterCell[] as; long b, s;
        
        //baseCount:记录某个元素组个数
        //并发量较大时，向 CounterCell[] as中添加数据
        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();
            }
        }
    }

    final long sumCount() {
        CounterCell[] as = counterCells; CounterCell a;
        long sum = baseCount;
        //判断是否已经向CounterCell[] as中添加数据
        if (as != null) {
            //遍历数组，每一个值使用+=方式存储近sum
            for (int i = 0; i < as.length; ++i) {
                if ((a = as[i]) != null)
                    sum += a.value;
            }
        }
        return sum;
    }
柚几哥哥
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
ConcurrentHashmap源码
02-18
源码分析见我博文：http://blog.csdn.net/wabiaozia/article/details/50684556
Java并发编程之ConcurrentHashMap
02-26
ConcurrentHashMap是一个线程安全的HashTable，它的主要功能是提供了一组和HashTable功能相同但是线程安全的方法。ConcurrentHashMap可以做到读取数据不加锁，并且其内部的结构可以让其在进行写操作的时候能够将锁的粒度保持地尽量地小，不用对整个ConcurrentHashMap加锁。ConcurrentHashMap为了提高本身的并发能力，在内部采用了一个叫做Segment的结构，一个Segment其实就是一个类HashTable的结构，Segment内部维护了一个链表数组，我们用下面这一幅图来看下ConcurrentHashMap的内部结构：从上面的结构
ConcurrentHashMap详解
最新发布
qq_62592925的博客
02-16 1116
Java 7 中的存储结构如上图，由很多个Segment组合，而每一个Segment是一个类似于HashMap的结构，所以每一个HashMap的内部可以进行扩容。但是Segment的个数一旦，默认Segment的个数是 16 个，你也可以认为默认支持最多 16 个线程并发。不难看出，ConcurrentHashMap采用了的方式，，而。为什么要用二次hash，主要原因是为了构造分离锁，使得对于map的修改不会锁住整个容器，提高并发能力。
Java并发系列之ConcurrentHashMap源码分析
08-27
主要为大家详细分析了Java并发系列之ConcurrentHashMap源码，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
Java中遍历ConcurrentHashMap的四种方式详解
08-25
主要介绍了Java中遍历ConcurrentHashMap的四种方式详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Java利用ConcurrentHashMap实现本地缓存demo
05-25
Java利用ConcurrentHashMap实现本地缓存demo； 基本功能有缓存有效期、缓存最大数、缓存存入记录、清理线程、过期算法删除缓存、LRU算法删除、获取缓存值等功能。 复制到本地项目的时候，记得改包路径哦~
Map 综述（三）：彻头彻尾理解 ConcurrentHashMap
热门推荐
Rico's Blogs
05-27 13万+
ConcurrentHashMap是J.U.C的重要成员，它是HashMap的一个线程安全的版本。在默认理想状态下，ConcurrentHashMap可以支持16个线程执行并发写操作及任意数量线程的读操作。本文将结合Java内存模型和JDK源代码，剖析其高并发的具体实现机制，包括在JDK中的定义和结构、并发存取、重哈希和跨段操作，并着重剖析了ConcurrentHashMap读操作不需要加锁的内在奥秘和原理。
深入浅出ConcurrentHashMap详解
学哥斌的博客
08-07 7万+
JDK7 版本的 ConcurrentHashMap 简单介绍，以及 JDK8 的改动
ConcurrentHashMap介绍
HFUTJungle的博客
07-22 2701
ConcurrentHashMap从JDK1.5开始随java.util.concurrent包一起引入JDK中，主要为了解决HashMap线程不安全和HashTable效率不高的问题。
HashMap 及 ConcurrentHashMap原理详解
码龙-的博客
02-20 1796
一.HashMap 的工作原理 1.hashing的概念 Hashing（散列法）是一种将字符组成的字符串转换为固定长度的数值的方法，称为散列法，也叫哈希法。 2.HashMap 内部结构 代码结构： 由上图可以看出，HashMap是数组和链表结合组成的复合结构，数组被分为一个个桶（bucket），每个桶可存储一个或多个Entry对象，在HashMap 中Node实现了Entry接口方法，每个Node对象包含四部分，分...
ConcurrentHashMap的使用介绍和底层原理解析和开源框架的使用实例
m0_71777195的博客
05-04 915
ConcurrentHashMap是JDK1.5提供的线程安全的HashMap,它允许多个线程并发访问哈希表,并发修改map中的数据而不会产生死锁。ConcurrentHashMap适用于高并发的环境下,可以替代synchronized实现的同步HashMap。ConcurrentHashMap的并发度很高,吞吐量也很高。ConcurrentHashMap通过锁分段技术,实现高度的并发访问,大大提高了HashMap的吞吐量,是高并发环境下一个很好的选择。
ConcurrentHashMap原理详解(太细了)
qq_42068856的博客
07-31 5万+
和HashMap一样，是一个存放键值对的容器。使用hash算法来获取值的地址，因此时间复杂度是O(1)。查询非常快。同时，是线程安全的HashMap。专门用于多线程环境。做插入操作时，首先进入乐观锁，然后，在乐观锁中判断容器是否初始化，如果没初始化则初始化容器，如果已经初始化，则判断该hash位置的节点是否为空，如果为空，则通过CAS操作进行插入。如果该节点不为空，再判断容器是否在扩容中，如果在扩容，则帮助其扩容。如果没有扩容，则进行最后一步，先加锁，然后找到hash。......
ConcurrentHashMap简介
gulanga5的博客
03-07 5万+
一、jdk1.8之前的数据结构： 1.默认情况下会有16个区段 Segment数组 Segment[16] 2.每次每个区段Segment中会保存若干个散列桶，每次散列桶长度扩容成2^n次方的长度。 多个散列桶相连就构成了散列表。 3.存入元素： key带入到hashcode方法众获得hashcode值，然后把hashcode值带入到散列算法中获取segment的下标(区段编号)，再根据key带入到定义好的函数中获取Segment对象中散列桶的下标。 如果此位置有元素就构成链表(JDK1.8及以后会
ConcurrentHashMap讲解
ZZYSY的博客
03-21 2764
什么是ConcurrentHashMap ConcurrentHashMap是线程安全且高效的HashMap 为什么要使用ConcurrentHashMap HashMap可能导致程序死循环 线程安全的HashTable效率非常低下 线程不安全的HashMap 下面代码使用HashMap进行put操作会引发死循环，CPU利用率接近100%，所以不能使用HashMap final HashMap<String, String> map = new HashMap<String, Str
图解ConcurrentHashMap
gqg_guan的博客
03-08 2007
ConcurrentHashMap,HashMap
concurrenthashmap
08-21
ConcurrentHashMap是Java中的一个线程安全的哈希表实现。它是HashMap的一个并发版本，用于在多线程环境下进行安全的操作。 与普通的HashMap不同，ConcurrentHashMap中的各个操作是并发安全的，可以被多个线程同时执行而不会导致数据不一致。这是通过使用一种称为分段锁（Segment Locks）的机制来实现的。 ConcurrentHashMap将整个数据结构分为多个段（Segment），每个段都是一个独立的哈希表。每个段都有自己的锁，当一个线程访问某个段时，只需要获取该段对应的锁，其他段的数据可以被其他线程同时访问，从而提高了并发性能。 ConcurrentHashMap还提供了一些特殊的操作，如putIfAbsent、remove、replace等，这些操作可以在不破坏并发安全性的前提下进行原子性操作。 总之，ConcurrentHashMap是一个高效、线程安全的哈希表实现，适用于多线程环境下的并发操作。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

柚几哥哥

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

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

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

打赏作者

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

抵扣说明：

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

余额充值