Java8 ConcurrentHashMap

最新推荐文章于 2022-11-11 12:17:22 发布
最新推荐文章于 2022-11-11 12:17:22 发布
阅读量93 收藏
点赞数
分类专栏： java base
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/eve_z/article/details/103164249
版权

ConcurrentHashMap

在这里插入图片描述

初始化

// 这构造函数里，什么都不干
public ConcurrentHashMap() {
}
public ConcurrentHashMap(int initialCapacity) {
    if (initialCapacity < 0)
        throw new IllegalArgumentException();
    // MAXIMUM_CAPACITY = 1 << 30;
    // TODO 不知道为什么他要向右移一位
    int cap = ((initialCapacity >= (MAXIMUM_CAPACITY >>> 1)) ?
               MAXIMUM_CAPACITY :
               // 一般情况下：tableSizeFor(initialCapacity * 1.5 + 1)
               // initialCapacity = 0：tableSizeFor(initialCapacity + 1)
               // initialCapacity = 1：tableSizeFor(initialCapacity + 1)
               tableSizeFor(initialCapacity + (initialCapacity >>> 1) + 1));
    this.sizeCtl = cap;
}
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
        long size = (long)(1.0 + (long)initialCapacity / loadFactor);
        int cap = (size >= (long)MAXIMUM_CAPACITY) ?
            MAXIMUM_CAPACITY : tableSizeFor((int)size);
        this.sizeCtl = cap;
    }

插入值 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 NullPointerException();
    // 得到 hash 值
    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)
            // 初始化数组，后面会详细介绍
            tab = initTable();
  
        // 找该 hash 值对应的数组下标，得到第一个节点 f
        else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
            // 如果数组该位置为空，
            //    用一次 CAS 操作将这个新值放入其中即可，这个 put 操作差不多就结束了，可以拉到最后面了
            //          如果 CAS 失败，那就是有并发操作，进到下一个循环就好了
            if (casTabAt(tab, i, null,
                         new Node<K,V>(hash, key, value, null)))
                break;                   // no lock when adding to empty bin
        }
        // hash 居然可以等于 MOVED，这个需要到后面才能看明白，不过从名字上也能猜到，肯定是因为在扩容
        else if ((fh = f.hash) == MOVED)
            // 帮助数据迁移，这个等到看完数据迁移部分的介绍后，再理解这个就很简单了
            tab = helpTransfer(tab, f);
  
        else { // 到这里就是说，f 是该位置的头结点，而且不为空
  
            V oldVal = null;
            // 获取数组该位置的头结点的监视器锁
            synchronized (f) {
                if (tabAt(tab, i) == f) {
                    if (fh >= 0) { // 头结点的 hash 值大于 0，说明是链表
                        // 用于累加，记录链表的长度
                        binCount = 1;
                        // 遍历链表
                        for (Node<K,V> e = f;; ++binCount) {
                            K ek;
                            // 如果发现了"相等"的 key，判断是否要进行值覆盖，然后也就可以 break 了
                            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;
                        }
                    }
                }
            }
            // binCount != 0 说明上面在做链表操作
            if (binCount != 0) {
                // 判断是否要将链表转换为红黑树，临界值和 HashMap 一样，也是 8
                if (binCount >= TREEIFY_THRESHOLD)
                    // 这个方法和 HashMap 中稍微有一点点不同，那就是它不是一定会进行红黑树转换，
                    // 如果当前数组的长度小于 64，那么会选择进行数组扩容，而不是转换为红黑树
                    //    具体源码我们就不看了，扩容部分后面说
                    treeifyBin(tab, i);
                if (oldVal != null)
                    return oldVal;
                break;
            }
        }
    }
    //
    addCount(1L, binCount);
    return null;
}

初始化数组：initTable

private final Node<K,V>[] initTable() {
    Node<K,V>[] tab; int sc;
    while ((tab = table) == null || tab.length == 0) {
        // 初始化的"功劳"被其他线程"抢去"了
        if ((sc = sizeCtl) < 0)
            Thread.yield(); // lost initialization race; just spin
        // CAS 一下，将 sizeCtl 设置为 -1，代表抢到了锁
        else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
            try {
                if ((tab = table) == null || tab.length == 0) {
                    // DEFAULT_CAPACITY 默认初始容量是 16
                    int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
                    // 初始化数组，长度为 16 或初始化时提供的长度
                    Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
                    // 将这个数组赋值给 table，table 是 volatile 的
                    table = tab = nt;
                    // 如果 n 为 16 的话，那么这里 sc = 12
                    // 其实就是 0.75 * n
                    sc = n - (n >>> 2);
                }
            } finally {
                // 设置 sizeCtl 为 sc，我们就当是 12 吧
                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) {
        // MIN_TREEIFY_CAPACITY 为 64
        // 所以，如果数组长度小于 64 的时候，其实也就是 32 或者 16 或者更小的时候，会进行数组扩容
        if ((n = tab.length) < MIN_TREEIFY_CAPACITY)
            // 数组扩容 n * 2
            tryPresize(n << 1);
        // b 是头结点
        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));
                }
            }
        }
    }
}

扩容：tryPresize

// 首先要说明的是，方法参数 size 传进来的时候就已经翻了倍了
private final void tryPresize(int size) {
    // c：size 的 1.5 倍，再加 1，再往上取最近的 2 的 n 次方。
    int c = (size >= (MAXIMUM_CAPACITY >>> 1)) ? MAXIMUM_CAPACITY :
        tableSizeFor(size + (size >>> 1) + 1);
    int sc;
    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); // 0.75 * n
                    }
                } finally {
                    sizeCtl = sc;
                }
            }
        }
        else if (c <= sc || n >= MAXIMUM_CAPACITY)
            break;
        else if (tab == table) {
            // TODO 没看懂 rs 的真正含义是什么
            int rs = resizeStamp(n);
 
            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;
                // 2. 用 CAS 将 sizeCtl 加 1，然后执行 transfer 方法
                //    此时 nextTab 不为 null
                if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
                    transfer(tab, nt);
            }
            // TODO 没看懂这里的交换每次交换的值都是负数为什么交换的expect是正数还可以交换成功
            // 1. 将 sizeCtl偏移量的值 设置为 (rs << RESIZE_STAMP_SHIFT) + 2)
            //  调用 transfer 方法，此时 nextTab 参数为 null
            else if (U.compareAndSwapInt(this, SIZECTL, sc,
                                         (rs << RESIZE_STAMP_SHIFT) + 2))
                transfer(tab, null);
        }
    }
}

TODO 数据迁移：transfer

读取值 get

  1. 根据 hash 值找到数组对应位置: (n – 1) & h
  2. 判断数组该位置处的元素是否刚好就是我们要找的，如果不是，走第三步
  3. 如果头结点的 hash 小于 0，说明 正在扩容，或者该位置是红黑树，如果不是，走第四步
  4. 遍历链表，直到找到相等(==或equals)的 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());
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (e = tabAt(tab, (n - 1) & h)) != null) {
        // 判断头结点是否就是我们需要的节点
        if ((eh = e.hash) == h) {
            if ((ek = e.key) == key || (ek != null && key.equals(ek)))
                return e.val;
        }
        // 如果头结点的 hash 小于 0，说明 正在扩容，或者该位置是红黑树
        else if (eh < 0)
            // 参考 ForwardingNode.find(int h, Object k) 和 TreeBin.find(int h, Object k)
            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;
        }
    }
    return null;
}

java 7/8区别

  1. 在 Java8 中，当链表中的元素超过了 8 个以后，会将链表转换为红黑树
  2. 线程安全
    • Java7 中使用Segment分块，在每个segment操作是将整个segment进行lock，以保证线程安全
    • Java8 中大量使用cas操作、并在数组位置的头结点不为空时使用synchronized进行线程安全保证
  3. Java7 中使用 Entry 来代表每个 HashMap 中的数据节点，Java8 中使用 Node
    • 链表的情况使用Node
    • 红黑树的情况使用 TreeNode
ecolifr
关注
专栏目录
Java8之ConcurrentHashMap实现原理
ddxd0406的博客
08-05 9189
在java8之前ConcurrentHashMap是使用分段锁来实现并发的，数据结构为hashmap（数组加链表）的基础上再套一层segment数组，锁加在segment元素上。java8实现了粒度更细的加锁，去掉了segment数组，直接使用synchronized锁住hash后得到的数组下标位置中的第一个元素 ，如下图，这样加锁比segment加锁能支持更高的并发量。 另外，在java8...
Java 8 ConcurrentHashMap源码中竟然隐藏着两个BUG
DD_Dddd的博客
04-26 2509
历史文章推荐： 1.ConcurrentHashMap中有十个提升性能的细节，你都知道吗？ 2. HashMap面试，看这一篇就够了 3. 七种方式教你在SpringBoot初始化时搞点事情 4. Java序列化的这三个坑千万要小心 5. Java中七个潜在的内存泄露风险，你知道几个？ 6. JDK 16新特性一览 7. 啥？用了并行流还更慢了 Java 7的ConcurrenHashMap的源码我建议大家都看看，那个版本的源码就是Java多线程编程的教科书。在Java 7的源码中，作者对悲观锁的使用非.
ConcurrentHashMap源码解析 3.put() 方法
How many ten years in the life time?
11-11 576
put() => putVal() 写数据大体流程 写前操作 ConcurrentHashMap 不允许 key 或 value 为 null，会抛出异常 写数据前，会先对 key 的 hash 值进行一次加工 spread() 写数据流程 整个写数据是一个 自旋 (死循环) 的操作。 情况1：当前的 table 还没有被初始化。调用 initTable() 去尝试初始化 table，然后继续自旋。 情况2：当前 table 已经被初始化，调用寻址算法 (hash & (table.length -1)
java8 concurrecy
dingweipeng1228的博客
03-22 115
https://winterbe.com/posts/2015/04/07/java8-concurrency-tutorial-thread-executor-examples/ 转载于:https://www.cnblogs.com/lijiale/p/10577125.html
JDK1.8中ConcurrentHashMap源码解析
小志的博客
11-16 1516
目录一、ConcurrentHashMap使用场景二、put方法的整体流程三、第一种情况（初始化table数组）1、initTable源码如下：2、sizeCtl3、流程解释四、第二种情况（寻址后的位置没有被占用）1、源码如下 一、ConcurrentHashMap使用场景 我们平时最常用的HashMap其实不是线程安全的，而当我们有多线程使用场景的时候，即想线程安全，又想拥有Map的能力，我们可以选择HashTable，因为它是针对我们常用的方法上面加上了synchronize锁，但是在高并发的场景下
java安装_第一次Java 8体验
cunfu5234的博客
12-18 78
java安装 像世界其他地方一样，我深深地爱上了Slack。 为什么？ 原因很多，但主要的原因是它提供了一种围绕通讯而非工具真正构建SDLC流程的新方法。 您认为这些天哪个更常见，杂乱无章的机智团队在荒野中四处徘徊，尽管有出色的想法和才华横溢，却无法执行任务？ 还是在每次卡牌活动前摆弄敏捷专家的团队，在他们无所事事的旅程中无休止地祝贺自己？ 当然是后者。 我看到有些哲学家会发出他的敏捷建议。 第...
Java 8 ConcurrentHashMap的使用原理
yang的博客
05-23 1323
ConcurrnetHashMap是J.U.C包里面提供的一个线程安全并且高效的HashMap，所以ConcurrentHashMap在并发编程的场景中使用的频率比较高。ConcurrentHashMap是Map的派生类，API基本和HashMap类似，主要就是get、put这些方法。接下来基于ConcurrentHashMap的put操作来分析ConcurrentHashMap的源码实现。 JD...
Java利用ConcurrentHashMap实现本地缓存demo
05-25
Java利用ConcurrentHashMap实现本地缓存demo； 基本功能有缓存有效期、缓存最大数、缓存存入记录、清理线程、过期算法删除缓存、LRU算法删除、获取缓存值等功能。 复制到本地项目的时候，记得改包路径哦~
java8 ConcurrentHashMap实现原理
最新发布
07-22
Java 8中的ConcurrentHashMap是线程安全的哈希表实现，它支持并发读写操作而不需要全局锁定。它的实现原理主要有以下几个方面： 1. 分段锁策略：ConcurrentHashMap将整个数据结构分成若干个Segment（段），每个...
Java中遍历ConcurrentHashMap的四种方式详解
08-25
Java中遍历ConcurrentHashMap的四种方式详解 Java中遍历ConcurrentHashMap的四种方式详解是Java开发中一个非常重要的知识点。ConcurrentHashMap是Java中一种高效且线程安全的HashMap实现，它提供了高效的读写操作...
Java8 ConcurrentHashMap详解（待补充图示）
weixin_38370441的博客
04-08 718
Java8 ConcurrentHashMap详解为什么要用ConcurrentHashMap?ConcurrentHashMap的结构HashEntry对象的不变性结构性修改操作：put、remove、clearSegment类ConcurrentHashMap类ConcurrentHashMap的操作put操作get操作size操作remove操作ConcurrentHashMap实现高并发的总结读操作的高效率比HashTable和HashMap拥有更高并发性ConcurrentHashMap的高并发性
Java8 ConcurrentHashMap详解
热门推荐
好好学java
02-27 4万+
Java8 ConcurrentHashMapJava7 中实现的 ConcurrentHashMap 说实话还是比较复杂的，Java8 对 ConcurrentHashMap 进行了比较大的改动。建议读者可以参考 Java8 中 HashMap 相对于 Java7 HashMap 的改动，对于 ConcurrentHashMap，Java8 也引入了红黑树。说实话，Java8 Concurrent
第九章Java8新增的并发笔记
hankin的博客
06-01 2398
一、原子操作CAS——LongAdder JDK1.8时，java.util.concurrent.atomic包中提供了一个新的原子类：LongAdder。根据Oracle官方文档的介绍，LongAdder在高并发的场景下会比它的前辈——AtomicLong 具有更好的性能，代价是消耗更多的内存空间。AtomicLong是利用了底层的CAS操作来提供并发性的，调用了Unsafe类的getAndA...
【HashMap】Java8 ConcurrentHashMap详解
keeper42的博客
01-28 992
Java8 ConcurrentHashMap Java7 中实现的 ConcurrentHashMap 说实话还是比较复杂的，Java8 对 ConcurrentHashMap 进行了比较大的改动。建议读者可以参考 Java8 中 HashMap 相对于 Java7 HashMap 的改动，对于 ConcurrentHashMap，Java8 也引入了红黑树。 说实话，Java8 ConcurrentHashMap 源码真心不简单，最难的在于扩容，数据迁移操作不容易看懂。 我们先用一个示意图来描述下
Java8开始ConcurrentHashMap,为什么舍弃分段锁
天才小站
12-27 1万+
概述 我们知道， 在 Java 5 之后，JDK 引入了 java.util.concurrent 并发包 ，其中最常用的就是ConcurrentHashMap 了， 它的原理是引用了内部的 Segment (ReentrantLock ) 分段锁，保证在操作不同段 map 的时候， 可以并发执行， 操作同段 map 的时候，进行锁的竞争和等待。从而达到线程安全， 且效率大于 synchr...
Java8总结之并发增强
听雪楼
08-29 1542
原子值 从 Java5 开始，java.util.concurrent.atonic包提供了用于支持无锁可变变量的类。 /** * 测试java8的并发增强 * @author lianghaining * */ public class TestThread { public static AtomicLong num = new AtomicLong(); ...
关于jdk1.8中ConcurrentHashMap的方方面面
不若乘风来
10-11 3万+
前言 Java JDK升级到1.8后有些集合类的实现有了变化，其中ConcurrentHashMap就有进行结构上的大调整。jdk1.6、1.7实现的共同点主要是通过采用分段锁Segment减少热点域来提高并发效率，1.8版本的实现有哪些变化呢？ 重要概念 在正式研究前，我们需要先知道几个重要参数，提前说明其值所代表的意义以便更好的讲解源码实现。 table 所有数据都存在tab...
ConcurrentHashMap源码深度解析（一）（java8）——不可不知的基本概念（助你拿下源码事半功倍）
你学废了吗？
03-14 782
ConcurrentHashMap java1.8数据结构采用数组+链表+红黑树，废弃分段锁`Segement`，进一步降低锁的粒度，可将锁直接加在数组占位节点上。同时发生哈希冲突的节点依然采用链表法，但是加了红黑树进行检索优化，即链表与红黑树互相转化，即使到了极端情况，检索的时间复杂度为O(lgn)，相对于O(n)性能提升不少。
【JUC并发编程】11 ConcurrentHashMap如何计算Size
健身变秃，coding变强
11-16 4026
一、前言 我们都知道，ConcurrentHashmap这个并发集合框架是线程安全的， 二、ConCurrentHashMap#size()方法
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值