Java并发编程之ConcurrentHashMap原理解析

简介: Java并发编程之ConcurrentHashMap原理解析

ConcurrentHashMap



  1. get


/**
 *  根据键值key获取value,根据key.equals方法判断两个元素是否相同
 *  @param key 键
 *  @return 如果key存在则返回对应的value,否则返回null
 */
public V get(Object key) {
    Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
    //将key的hashcode进一步散列,减少hash碰撞
    int h = spread(key.hashCode());
    //具体的元素信息是存在Node[]数组中,先判断key对应hash值映射到数组元素的位置释放有值
    //如果对应的数组位置没有值,直接返回null,否则继续判断
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (e = tabAt(tab, (n - 1) & h)) != null) {
        //如果当前数组位置的元素的hash值和key值均相等,则直接返回
        if ((eh = e.hash) == h) {
            if ((ek = e.key) == key || (ek != null && key.equals(ek)))
                return e.val;
        }
        //如果hash值为负数,说明相同hash值的元素组成了红黑树,则直接在红黑数内部查找:TreeBin.find
        else if (eh < 0)
            return (p = e.find(h, key)) != null ? p.val : null;
        //有相同hash值(发生了hash碰撞)的元素组成一个链表,依次在链表中查询目标元素
        while ((e = e.next) != null) {
            if (e.hash == h &&
                ((ek = e.key) == key || (ek != null && key.equals(ek))))
                return e.val;
        }
    }
    return null;
}


可以看到get操作完全没有加锁,那么多线程操作的时候如何保证正确性呢?通过上面get操作的源码可以看到,每一个key,value会被封装成一个Node,继续看Node的源码。


2.Node:


static class Node<K,V> implements Map.Entry<K,V> {
    final int hash;
    final K key;
    //value为volatile类型的,从而保证了多线程读写的可见性
    volatile V val;
    //发生hash碰撞时,记录下一个元素,类型也是volatile的,从而保证可见性
    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;
    }
}


这里ConcurrentHashMap是使用volatile来保证多线程操作的可见性的,从而避免了加锁逻辑。


3.put:


public V put(K key, V value) {
    //具体的实现逻辑在putVal
    return putVal(key, value, false);
}
/**
  * 将key,value键值对放入到map中
  * @param key 键
  * @param value 值
  * @return 如果先前key的位置有值,则返回老的值,否则返回null
  */
final V putVal(K key, V value, boolean onlyIfAbsent) {
    //可以看到ConcurrentHashMap的key和value都不允许为null
    if (key == null || value == null) throw new NullPointerException();
    //将key的hashcode进一步散列,减少hash碰撞
    int hash = spread(key.hashCode());
    int binCount = 0;
    for (Node<K,V>[] tab = table;;) {
        Node<K,V> f; int n, i, fh;
        //记录元素的Node数组为null时要先进行初始化
        if (tab == null || (n = tab.length) == 0)
            //初始化table,见下文分析
            tab = initTable();
        //如果当前位置为null,可以直接放入元素
        else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
            //CAS写入元素,如果成功则返回;CAS失败说明有另外的线程在进行put操作,需要自旋等待
            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);
        else {//当前数组位置已经有值了
            V oldVal = null;
            //对当前节点加锁,防止其他线程并发更新
            synchronized (f) {
                if (tabAt(tab, i) == f) {//防止其他线程更改tabb在i位置的值,如果发生更新则继续循环
                    if (fh >= 0) {//hash值相同的节点为链表
                        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;
                                //putIfAbsent?
                                if (!onlyIfAbsent)
                                    e.val = value;
                                break;
                            }
                            Node<K,V> pred = e;
                            //更新节点的next节点为新加入的节点
                            if ((e = e.next) == null) {
                                pred.next = new Node<K,V>(hash, key,
                                                          value, null);
                                break;
                            }
                        }
                    }
                    //如果hash值相同的节点为红黑树,则在红黑树内部执行节点新增或者更新逻辑
                    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;
                        }
                    }
                }
            }
            //hash值相同的元素个数>0
            if (binCount != 0) {
                //节点超过8个,若<64则扩容链表,否则从链表转化为红黑树,提升查询效率
                if (binCount >= TREEIFY_THRESHOLD)
                    treeifyBin(tab, i);
                if (oldVal != null)
                    return oldVal;
                break;
            }
        }
    }
    //增加数组元素个数,并判断是否需要扩容,若需要则进行扩容操作
    addCount(1L, binCount);
    return null;
}
/**
  * 初始化Node数组
  */
private final Node<K,V>[] initTable() {
    Node<K,V>[] tab; int sc;
    //数组为空时,持续循环
    while ((tab = table) == null || tab.length == 0) {
        //sc == -1,说明有多个线程同时在执行初始化操作,此线程竞争失败,让出cpu执行权
        if ((sc = sizeCtl) < 0)
            Thread.yield(); //让出cpu控制权,自旋等待
        else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {//cas成功,进行初始化,并将sizectl的值设置为-1
            try {
                if ((tab = table) == null || tab.length == 0) {
                    int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
                    @SuppressWarnings("unchecked")
                    Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
                    table = tab = nt;
                    sc = n - (n >>> 2);
                }
            } finally {
                sizeCtl = sc;
            }
            break;
        }
    }
    return tab;
}


4.总结:可以看到ConcurrentHashMap的get操作完全没有加锁,put操作只有在hash碰撞的时候才会在冲突节点上加上Sychronized锁,整体的效率是非常高的。另外,需要注意的是:在执行put操作的时候,会进行扩容操作,而扩容时候比较耗时的,在实际应用过程中,如果需要大量数据的频繁写入,可以在初始化的时候指定一个较大的容量,避免频率扩容带来的开销。


目录
打赏
0
0
0
0
4
分享
相关文章
2025 最新史上最全 Java 面试题独家整理带详细答案及解析
本文从Java基础、面向对象、多线程与并发等方面详细解析常见面试题及答案,并结合实际应用帮助理解。内容涵盖基本数据类型、自动装箱拆箱、String类区别,面向对象三大特性(封装、继承、多态),线程创建与安全问题解决方法,以及集合框架如ArrayList与LinkedList的对比和HashMap工作原理。适合准备面试或深入学习Java的开发者参考。附代码获取链接:[点此下载](https://pan.quark.cn/s/14fcf913bae6)。
161 48
Redis 实操要点:Java 最新技术栈的实战解析
本文介绍了基于Spring Boot 3、Redis 7和Lettuce客户端的Redis高级应用实践。内容包括:1)现代Java项目集成Redis的配置方法;2)使用Redisson实现分布式可重入锁与公平锁;3)缓存模式解决方案,包括布隆过滤器防穿透和随机过期时间防雪崩;4)Redis数据结构的高级应用,如HyperLogLog统计UV和GeoHash处理地理位置。文章提供了详细的代码示例,涵盖Redis在分布式系统中的核心应用场景,特别适合需要处理高并发、分布式锁等问题的开发场景。
113 38
|
18天前
|
Java Redis 面试题集锦 常见高频面试题目及解析
本文总结了Redis在Java中的核心面试题,包括数据类型操作、单线程高性能原理、键过期策略及分布式锁实现等关键内容。通过Jedis代码示例展示了String、List等数据类型的操作方法,讲解了惰性删除和定期删除相结合的过期策略,并提供了Spring Boot配置Redis过期时间的方案。文章还探讨了缓存穿透、雪崩等问题解决方案,以及基于Redis的分布式锁实现,帮助开发者全面掌握Redis在Java应用中的实践要点。
57 6
2025 年最新 Java 面试从基础到微服务实战指南全解析
《Java面试实战指南:高并发与微服务架构解析》 本文针对Java开发者提供2025版面试技术要点,涵盖高并发电商系统设计、微服务架构实现及性能优化方案。核心内容包括:1)基于Spring Cloud和云原生技术的系统架构设计;2)JWT认证、Seata分布式事务等核心模块代码实现;3)数据库查询优化与高并发处理方案,响应时间从500ms优化至80ms;4)微服务调用可靠性保障方案。文章通过实战案例展现Java最新技术栈(Java 17/Spring Boot 3.2)的应用.
81 9
|
17天前
|
Java 抽象类与接口在 Java17 + 开发中的现代应用实践解析
《Java抽象类与接口核心技术解析》 摘要:本文全面剖析Java抽象类与接口的核心概念与技术差异。抽象类通过模板设计实现代码复用,支持具体方法与状态管理;接口则定义行为规范,实现多态支持。文章详细对比了两者在实例化、方法实现、继承机制等方面的区别,并提供了模板方法模式(抽象类)和策略模式(接口)的典型应用示例。特别指出Java8+新特性为接口带来的灵活性提升,包括默认方法和静态方法。最后给出最佳实践建议:优先使用接口定义行为规范,通过抽象类实现代码复用,合理组合两者构建灵活架构。
32 2
应届生面试高频 Java 基础问题及详细答案解析
摘要: Java数据类型分为基本类型(如int、float等)和引用类型(如类、数组)。final可修饰类、方法和变量,使其不可继承、重写或修改。static用于类级别的变量和方法,共享于所有实例。&quot;==&quot;比较基本类型的值或引用类型的地址,而equals比较对象内容(需重写)。Java只有值传递,对于引用类型传递的是地址副本。String对象不可变,拼接操作会创建新对象而非修改原对象。Java 10的var支持类型推断,Java 16的Record提供不可变类简化。
36 0
应届生面试高频 Java 基础问题及实操示例解析
本文总结了Java基础面试中的高频考点,包括数据类型分类、final修饰符的三种用途、static关键字特性、==与equals的区别、Java只有值传递的特性、String的不可变性、Error与Exception的差异、程序初始化顺序规则,以及IO流的字节流/字符流分类。每个问题都配有简明定义和典型示例,如用final修饰变量示例、static方法调用限制说明等,帮助应聘者快速掌握核心概念和实际应用场景。
26 0
Java 集合容器常见面试题及详细解析
本文全面解析Java集合框架,涵盖基础概念、常见接口与类的特点及区别、底层数据结构、线程安全等内容。通过实例讲解List(如ArrayList、LinkedList)、Set(如HashSet、TreeSet)、Map(如HashMap、TreeMap)等核心组件,帮助读者深入理解集合容器的使用场景与性能优化。适合准备面试或提升开发技能的开发者阅读。
31 0
Java集合源码解析-ConcurrentHashMap(JDK8)(下)
Java集合源码解析-ConcurrentHashMap(JDK8)
166 0
Java集合源码解析-ConcurrentHashMap(JDK8)(下)
AI助理

你好,我是AI助理

可以解答问题、推荐解决方案等