ConcurrentHashMap原理与源码分析

已于 2025-04-28 09:35:39 修改
阅读量1.1k 收藏 29
点赞数 40
分类专栏： 并发 集合 文章标签： java 开发语言
于 2025-04-28 09:18:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_54879811/article/details/147560712
版权

ConcurrentHashMap原理与源码分析

1. 引言

在Java并发编程中，ConcurrentHashMap是一个至关重要的数据结构，它解决了普通HashMap在多线程环境下的线程安全问题，同时克服了Hashtable和Collections.synchronizedMap()在高并发场景下的性能瓶颈。本文将深入分析ConcurrentHashMap的设计原理、内部实现和源码细节，帮助读者彻底理解这一高性能并发集合类。

2. 为什么需要ConcurrentHashMap？

2.1 HashMap的线程安全问题

在多线程环境下，HashMap存在以下安全隐患：

  1. 数据不一致：多个线程同时修改可能导致最终结果不确定
  2. 死循环：在JDK 1.7中，并发扩容时可能导致链表形成环，从而引发死循环
  3. 数据丢失：并发插入时可能覆盖彼此的更新

示例代码：

// 线程不安全的HashMap示例
HashMap<String, Integer> unsafeMap = new HashMap<>();

// 多线程并发修改可能导致问题
new Thread(() -> {
    for (int i = 0; i < 1000; i++) {
        unsafeMap.put("key" + i, i);  // 可能与其他线程冲突
    }
}).start();

new Thread(() -> {
    for (int i = 0; i < 1000; i++) {
        unsafeMap.put("key" + i, i + 1);  // 可能与其他线程冲突
    }
}).start();

// 最终结果不可预测

2.2 传统解决方案的局限

  1. Hashtable：

    • 使用synchronized方法确保线程安全
    • 所有操作都锁定整个表，串行执行
    • 在高并发场景下性能急剧下降

  2. Collections.synchronizedMap(HashMap)：

    • 本质上与Hashtable类似，使用同步包装器
    • 也是对整个Map加锁，导致线程间相互阻塞
// 传统线程安全Map示例
Hashtable<String, Integer> table = new Hashtable<>();
Map<String, Integer> syncMap = Collections.synchronizedMap(new HashMap<>());

// 这两种方式在高并发下都会有性能问题，因为所有操作都需要获取同一把锁

2.3 ConcurrentHashMap的优势

ConcurrentHashMap设计目标是在保证线程安全的同时，实现高并发性能：

  1. 分段锁设计（JDK 1.7）：将Map分为多个段，每个段独立加锁
  2. 细粒度锁 + CAS操作（JDK 1.8）：锁定桶（bin）级别，进一步提高并发性
  3. 读操作无锁：完全不加锁，提高读取性能
  4. 弱一致性：牺牲强一致性换取高性能，适合大多数场景

3. JDK 1.7中的ConcurrentHashMap实现

3.1 整体结构

JDK 1.7中的ConcurrentHashMap采用分段锁（Segment）机制：
在这里插入图片描述

public class ConcurrentHashMap<K, V> extends AbstractMap<K, V> implements ConcurrentMap<K, V> {
    /**
     * Segment表数组，每个Segment相当于一个小的Hashtable
     */
    final Segment<K,V>[] segments;
    
    // 其他字段...
    
    /**
     * Segment静态内部类
     */
    static final class Segment<K,V> extends ReentrantLock implements Serializable {
        transient volatile HashEntry<K,V>[] table;
        transient int count;  // 元素计数
        transient int modCount;  // 修改计数
        transient int threshold;  // 扩容阈值
        final float loadFactor;  // 负载因子
        
        // 其他字段和方法...
    }
    
    /**
     * HashEntry静态内部类，存储键值对，形成链表
     */
    static final class HashEntry<K,V> {
        final K key;  // 键是不可变的
        final int hash;  // hash值也是不可变的
        volatile V value;  // 值可能变化，使用volatile保证可见性
        volatile HashEntry<K,V> next;  // next指针也使用volatile修饰
        
        // 构造函数和其他方法...
    }
}

核心特点：

  1. 分段设计：默认16个Segment，每个Segment独立加锁
  2. 继承结构：Segment继承自ReentrantLock，直接作为锁使用
  3. 不可变性：key和hash是final的，保证线程安全
  4. 可见性：value和next是volatile的，保证可见性

3.2 源码分析：关键操作

3.2.1 初始化过程
public ConcurrentHashMap(int initialCapacity, float loadFactor, int concurrencyLevel) {
    // 参数检查...
    
    // 计算segments数组的大小，必须是2的幂
    int sshift = 0;
    int ssize = 1;
    while (ssize < concurrencyLevel) {
        ++sshift;
        ssize <<= 1;
    }
    
    // segmentShift和segmentMask用于定位segment
    this.segmentShift = 32 - sshift;
    this.segmentMask = ssize - 1;
    
    // 设置每个segment的容量
    int c = initialCapacity / ssize;
    if (c * ssize < initialCapacity)
        ++c;
    int cap = MIN_SEGMENT_TABLE_CAPACITY;
    while (cap < c)
        cap <<= 1;
        
    // 创建segments数组
    Segment<K,V> s0 =
        new Segment<K,V>(loadFactor, (int)(cap * loadFactor), (HashEntry<K,V>[])new HashEntry[cap]);
    Segment<K,V>[] ss = (Segment<K,V>[])new Segment[ssize];
    UNSAFE.putOrderedObject(ss, SBASE, s0); // 使用Unsafe类初始化第一个Segment
    this.segments = ss;
}

关键点：

  • concurrencyLevel决定分段数量，默认为16
  • 分段数必须是2的幂，便于计算
  • 使用Unsafe类初始化，提高性能
3.2.2 put操作
public V put(K key, V value) {
    Segment<K,V> s;
    if (value == null)
        throw new NullPointerException();
    int hash = hash(key);  // 计算hash值
    
    // 计算segment索引
    int j = (hash >>> segmentShift) & segmentMask;
    
    // 使用Unsafe类获取segment，不存在则初始化
    if ((s = (Segment<K,V>)UNSAFE.getObject(segments, (j << SSHIFT) + SBASE)) == null)
        s = ensureSegment(j);
        
    // 调用segment的put方法
    return s.put(key, hash, value, false);
}

// Segment的put方法
final V put(K key, int hash, V value, boolean onlyIfAbsent) {
    // 获取锁
    HashEntry<K,V> node = tryLock() ? null : scanAndLockForPut(key, hash, value);
    V oldValue;
    try {
        HashEntry<K,V>[] tab = table;
        // 计算桶的索引
        int index = (tab.length - 1) & hash;
        // 获取桶中的第一个节点
        HashEntry<K,V> first = entryAt(tab, index);
        
        // 遍历链表
        for (HashEntry<K,V> e = first; e != null; e = e.next) {
            K k;
            // 找到相同的key，更新值
            if ((k = e.key) == key || (e.hash == hash && key.equals(k))) {
                oldValue = e.value;
                if (!onlyIfAbsent) {
                    e.value = value;  // 更新值
                    ++modCount;
                }
                break;
            }
            node = e;
        }
        
        // 没有找到key，创建新节点
        if (node == null) {
            // 创建新节点并添加到链表头部
            HashEntry<K,V> newNode = new HashEntry<K,V>(hash, key, value, first);
            setEntryAt(tab, index, newNode);
            ++modCount;
            // 元素计数增加
            int c = count + 1;
            // 检查是否需要扩容
            if (c > threshold && tab.length < MAXIMUM_CAPACITY)
                rehash();  // 扩容
            count = c;
            oldValue = null;
        }
        
        return oldValue;
    } finally {
        unlock();  // 释放锁
    }
}

关键点：

  • 先定位Segment，再在Segment内部进行操作
  • 使用tryLock()尝试获取锁，失败则调用scanAndLockForPut
  • scanAndLockForPut会自旋获取锁，并预先构建节点，提高性能
  • 每个Segment独立管理自己的扩容
3.2.3 get操作
public V get(Object key) {
    Segment<K,V> s; // 声明segment局部变量
    HashEntry<K,V>[] tab;
    int h = hash(key);  // 计算hash值
    
    // 计算segment索引
    long u = (((h >>> segmentShift) & segmentMask) << SSHIFT) + SBASE;
    
    // 先获取segment，如果segment存在且该segment的table不为空
    if ((s = (Segment<K,V>)UNSAFE.getObjectVolatile(segments, u)) != null &&
        (tab = s.table) != null) {
            
        // 在segment的table中查找，不需要加锁
        for (HashEntry<K,V> e = (HashEntry<K,V>) UNSAFE.getObjectVolatile
                 (tab, ((long)(((tab.length - 1) & h)) << TSHIFT) + TBASE);
             e != null; e = e.next) {
                 
            K k;
            if ((k = e.key) == key || (e.hash == h && key.equals(k)))
                return e.value;  // 找到key，返回value
        }
    }
    return null;  // 未找到key，返回null
}

关键点：

  • get操作完全不加锁，利用volatile保证可见性
  • 使用Unsafe.getObjectVolatile方法获取最新的引用值
  • 由于key和hash是final的，value和next是volatile的，保证了读取的线程安全性

3.3 JDK 1.7实现的优缺点

优点：

  • 分段锁设计大幅提高了并发性能
  • 实现了所有ConcurrentMap接口定义的原子操作
  • 迭代器不会抛出ConcurrentModificationException

缺点：

  • 分段锁粒度仍然较粗
  • Segment数量一旦初始化就无法改变
  • 计算Segment索引的过程稍复杂，有一定性能开销

4. JDK 1.8中的ConcurrentHashMap实现

4.1 整体结构

在这里插入图片描述

JDK 1.8彻底重构了ConcurrentHashMap：

public class ConcurrentHashMap<K,V> extends AbstractMap<K,V> implements ConcurrentMap<K,V> {
    // 最大容量
    private static final int MAXIMUM_CAPACITY = 1 << 30;
    
    // 默认初始容量
    private static final int DEFAULT_CAPACITY = 16;
    
    // 负载因子
    private static final float LOAD_FACTOR = 0.75f;
    
    // 树化阈值，链表长度超过8转为红黑树
    static final int TREEIFY_THRESHOLD = 8;
    
    // 树退化阈值
    static final int UNTREEIFY_THRESHOLD = 6;
    
    // 树化的最小容量
    static final int MIN_TREEIFY_CAPACITY = 64;
    
    // Node数组，存储数据
    transient volatile Node<K,V>[] table;
    
    // 下一个要使用的table，只有在扩容时非空
    private transient volatile Node<K,V>[] nextTable;
    
    // 计数基值
    private transient volatile long baseCount;
    
    // 计数器数组，用于高并发计数
    private transient volatile CounterCell[] counterCells;
    
    // 扩容控制标记
    private transient volatile int sizeCtl;
    
    // 其他字段...
}

核心改变：

  1. 移除Segment：不再使用分段锁设计
  2. 采用Node数组：与HashMap结构相似
  3. 使用synchronized和CAS：实现细粒度的锁控制
  4. 支持红黑树：当链表过长时转为红黑树，提高查找性能
  5. 复杂的计数器设计：使用baseCount加CounterCell数组，提高并发计数性能

4.2 关键内部类

// 基本节点类，存储key-value对
static class Node<K,V> implements Map.Entry<K,V> {
    final int hash;
    final K key;
    volatile V val;  // volatile保证可见性
    volatile Node<K,V> next;  // volatile保证可见性
    
    // 构造函数和Entry接口方法...
    
    // 查找方法
    Node<K,V> find(int h, Object k) {
        Node<K,V> e = this;
        if (k != null) {
            do {
                K ek;
                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;  // 红黑树颜色标记
    
    // 树操作相关方法...
}

// 转发节点，仅在扩容期间使用
static final class ForwardingNode<K,V> extends Node<K,V> {
    final Node<K,V>[] nextTable;  // 指向扩容后的新表
    
    ForwardingNode(Node<K,V>[] tab) {
        super(MOVED, null, null, null);  // MOVED是一个特殊的hash值
        this.nextTable = tab;
    }
    
    // 在nextTable中查找
    Node<K,V> find(int h, Object k) {
        // 使用特殊算法在nextTable中查找
    }
}

// 空值占位符
static final class ReservationNode<K,V> extends Node<K,V> {
    ReservationNode() {
        super(RESERVED, null, null, null);  // RESERVED是特殊hash值
    }
    
    Node<K,V> find(int h, Object k) {
        return null;
    }
}

4.3 源码分析：关键操作

4.3.1 初始化过程
// 默认构造函数
public ConcurrentHashMap() {
}

// 带初始容量的构造函数
public ConcurrentHashMap(int initialCapacity) {
    if (initialCapacity < 0)
        throw new IllegalArgumentException();
    int cap = ((initialCapacity >= (MAXIMUM_CAPACITY >>> 1)) ?
               MAXIMUM_CAPACITY :
               tableSizeFor(initialCapacity + (initialCapacity >>> 1) + 1));
    this.sizeCtl = cap;  // sizeCtl保存初始容量
}

// 真正的初始化在第一次put操作时进行
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();  // 暂让出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;  // 使用sizeCtl或默认容量
                    @SuppressWarnings("unchecked")
                    Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];  // 创建Node数组
                    table = tab = nt;
                    sc = n - (n >>> 2);  // sc = 0.75n，设置扩容阈值
                }
            } finally {
                sizeCtl = sc;  // 恢复sizeCtl为扩容阈值
            }
            break;
        }
    }
    return tab;
}

关键点：

  • 延迟初始化：只有在第一次使用时才真正分配内存
  • 使用CAS保证只有一个线程执行初始化
  • sizeCtl是一个控制标识符：
    • sizeCtl > 0：表示下一次扩容的阈值
    • sizeCtl = -1：表示正在初始化
    • sizeCtl < -1：表示有-sizeCtl-1个线程正在进行扩容
    • sizeCtl = 0：默认值
4.3.2 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();
    int hash = spread(key.hashCode());  // 计算hash值
    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();  // 1. 初始化表
        else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {  // 2. 桶为空，直接CAS插入
            if (casTabAt(tab, i, null, new Node<K,V>(hash, key, value, null)))
                break;  // 无竞争，CAS成功，退出循环
        }
        else if ((fh = f.hash) == MOVED)  // 3. 发现ForwardingNode，说明正在扩容
            tab = helpTransfer(tab, f);  // 帮助扩容
        else {  // 4. 桶不为空，且不在迁移，锁定头节点
            V oldVal = null;
            synchronized (f) {  // 对头节点加锁
                if (tabAt(tab, i) == f) {  // 检查头节点是否被修改
                    if (fh >= 0) {  // 普通链表节点
                        binCount = 1;
                        for (Node<K,V> e = f;; ++binCount) {  // 遍历链表
                            K ek;
                            // 找到相同的key，更新value
                            if (e.hash == hash && ((ek = e.key) == key || (ek != null && key.equals(ek)))) {
                                oldVal = e.val;
                                if (!onlyIfAbsent)
                                    e.val = value;  // 更新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;
                        // 调用红黑树的putTreeVal方法
                        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;
}

关键点：

  • 使用自旋+CAS解决竞争问题
  • 只对链表/树的头节点加锁，细粒度锁
  • 发现正在扩容则帮助扩容
  • 链表过长转换为红黑树
  • 计数器使用复杂的addCount方法，支持高并发计数
4.3.3 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());
    
    // 如果表存在且对应的桶不为空
    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;  // 第一个节点就是要找的，直接返回
        }
        // 处理特殊节点（如ForwardingNode、TreeBin）
        else if (eh < 0)
            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;  // 未找到
}

关键点：

  • get方法完全无锁，依靠volatile变量保证可见性
  • 通过tabAt方法获取最新的桶头节点
  • 优先检查第一个节点，然后是特殊节点，最后是链表
4.3.4 扩容过程
private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
    int n = tab.length, stride;
    
    // 计算每个线程负责迁移的桶区间
    if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
        stride = MIN_TRANSFER_STRIDE;
        
    // 如果nextTab为空，初始化新表，容量翻倍
    if (nextTab == null) {
        try {
            @SuppressWarnings("unchecked")
            Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n << 1];
            nextTab = nt;
        } catch (Throwable ex) {
            sizeCtl = Integer.MAX_VALUE;  // 扩容失败，把sizeCtl设为最大值
            return;
        }
        nextTable = nextTab;
        transferIndex = n;  // 初始化转移索引
    }
    
    int nextn = nextTab.length;
    // 创建ForwardingNode，标记已经处理过的桶
    ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);
    boolean advance = true;  // 是否继续向前处理下一个桶
    boolean finishing = false;  // 是否完成扩容
    
    // i是当前处理的桶索引，bound是边界
    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) {  // 所有桶都处理完了
                nextTable = null;
                table = nextTab;  // 更新table引用
                sizeCtl = (n << 1) - (n >>> 1);  // 更新sizeCtl为新容量的0.75倍
                return;
            }
            // 当前线程完成任务，递减扩容线程计数
            if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
                if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)
                    return;  // 不是最后一个线程，直接返回
                finishing = advance = true;  // 是最后一个线程，设置finishing为true
                i = n;  // 重新检查一遍
            }
        }
        else if ((f = tabAt(tab, i)) == null)  // 桶为空
            advance = casTabAt(tab, i, null, fwd);  // CAS设置ForwardingNode
        else if ((fh = f.hash) == MOVED)  // 已经是ForwardingNode
            advance = true;
        else {  // 需要迁移的桶
            synchronized (f) {  // 加锁
                if (tabAt(tab, i) == f) {  // 再次检查头节点是否被修改
                    Node<K,V> ln, hn;  // 低位链表和高位链表
                    if (fh >= 0) {  // 普通链表节点
                        // 根据扩容后的哈希位确定节点位置
                        int runBit = fh & n;  // n是旧容量，用于确定高位的0/1
                        Node<K,V> lastRun = f;
                        // 找到最后一段全是0或全是1的子链表
                        for (Node<K,V> p = f.next; p != null; p = p.next) {
                            int b = p.hash & n;
                            if (b != runBit) {
                                runBit = b;
                                lastRun = p;
                            }
                        }
                        // 根据runBit分配低位链表或高位链表
                        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
ConcurrentHashMap原理与源码解读
风吟
07-28 555
一. ConcurrentHashMap 概述 HashMap 是 Java Collection Framework 的重要成员，也是Map族(如下图所示)中我们最为常用的一种。不过遗憾的是，HashMap不是线程安全的。也就是说，在多线程环境下，操作HashMap会导致各种各样的线程安全问题，比如在HashMap扩容重哈希时出现的死循环问题，脏读问题等。HashMap的这一缺点往往会造成诸多不...
ConcurrentHashMap实现原理及源码分析
qq_39081511的博客
06-07 151
转自：https://www.cnblogs.com/chengxiao/p/6842045.html　　ConcurrentHashMap是Java并发包中提供的一个线程安全且高效的HashMap实现（若对HashMap的实现原理还不甚了解，可参考我的另一篇文章HashMap实现原理及源码分析），ConcurrentHashMap在并发编程的场景中使用频率非常之高，本文就来分析下Concurre...
ConcurrentHashMap原理分析（1.7）
diweikang的博客
03-27 1334
一、出现背景 1、线程不安全的HashMap 先说HashMap，HashMap是线程不安全的，在并发环境下，可能会形成环状链表（扩容时可能造成，具体原因自行百度google或查看源码分析，参考https://blog.csdn.net/diweikang/article/details/89198811），导致get操作时cpu空转，所以，在并发环境中使用HashMap是非常危险的...
JDK源码分析系列之二：ConcurrentHashMap原理解析
2401_85767411的博客
06-17 786
/ 如果数组该位置为空，用一次 CAS 操作将这个新值放入其中即可，这个 put 操作差不多就结束了， 如果 CAS 失败，那就是有并发操作，进到下一个循环。// MIN_TREEIFY_CAPACITY 为 64，如果数组长度小于 64 的时候，其实也就是 32 或者 16 或者更小的时候，会进行数组扩容。的源码分析，这个方法的核心在于 sizeCtl 值的操作，首先将其设置为一个负数，然后执行。//c：size 的 1.5 倍，再加 1，再往上取最近的 2 的 n 次方。
【ConcurrentHashMap】JDK1.7版本源码解读与分析
wdx7770的博客
08-09 1717
底层是一个Segment[]数组, 每个Segment对象内部又有一个Entry[ ]数组, 一个Entry[]数组就相当于一个HashMapEntry[ ]采用拉链法解决冲突, 但是没有红黑树,红黑树是1.8才引入的;一个Segment对象就是一个段;当往容器中添加元素调用 put 方法时, 锁的粒度就是一个段;调用 put 方法时, 先计算应该放到Segment[ ]中的哪个段, 然后调用方法将 Entry 插入到，可以看出, 一次插入有两次散列，一次选择段, 一次选择段内的位置;
多线程编程(13)之ConcurrentHashMap深度源码分析
jokeMqc的博客
05-30 925
学习ConcurrentHashMap基本概念以及它底层的数据结构。数据结构如下：数组+链表+红黑树+锁(synchronized+cas)。
程序员面试加薪必备:ConcurrentHashMap底层原理与源码分析深入详解
08-31
程序员面试加薪必备_ConcurrentHashMap底层原理与源码分析深入详解
深入理解ConcurrentHashMap源码解析
一名后端程序猿
12-06 1347
1.7采用segment加reentrantLock实现，而1.8采用CAS和synchronized以及volatile实现。
Java语言ConcurrentHashMap实现原理及源码分析
专注基础架构领域
08-07 336
ConcurrentHashMap是Java并发包中提供的一个线程安全且高效的HashMap实现（若对HashMap的实现原理还不甚了解，可参考我的另一篇文章HashMap实现原理及源码分析），ConcurrentHashMap在并发编程的场景中使用频率非常之高，本文就来分析下ConcurrentHashMap的实现原理，并对其实现原理进行分析（JDK1.7). ConcurrentHashMa...
ConcurrentHashMap 原理
liuwg1226的专栏
08-09 4932
一 概述 我们都知道 HashMap 不是线程安全的，所以在处理并发的时候会出现问题。 而 HashTable 虽然是线程安全的，但是是通过整个方法来加锁的方式，当一个线程在写操作的时候，另外的线程则不能进行读写。 而 ConcurrentHashMap 则可以支持并发的读写。跟 1.7 版本相比，1.8 版本又有了很大的变化，已经抛弃了 Segment 的概念，虽然源码里面还保留了，也只是为了兼容性的考虑。 二 ConcurrentHashMap 原理 在 ConcurrentHashMap 中通过一个
基于ssm的校园外卖配送系统（源码+文档）
luoluoal的博客
04-30 1319
校园外卖配送系统的主要使用者分为：1、用户的功能及权限用户登录注册后，进入系统对个人中心，订单信息管理，订单取消管理，配送接单管理，取消配送管理，送达通知管理等功能进行操作管理。2、配送员的功能及权限用户登录注册后，进入系统对个人中心，订单信息管理，配送接单管理，取消配送管理，送达通知管理等功能进行操作管理。3、管理员的功能及权限用户信息的添加和管理，校园外卖配送详细信息添加和管理和文档信息添加和管理以及网站信息管理，这些都是管理员的功能💕💕作者：落落。
用Java模拟打字：深入解析 java.awt.Robot 的键盘控制艺术
码觉客的博客
04-28 2644
通过，我们可以实现强大的键盘自动化功能。对于简单的字符（英文字母、数字、基础标点等），可以通过模拟单个按键的按下和释放（可能需要配合 Shift 等修饰键）来实现，这需要建立字符到键码的映射并注意按键时序和延迟。对于复杂字符、中文或长文本，由于Robot不理解输入法逻辑，最可靠和常用的方法是将文本复制到系统剪贴板，然后模拟按下系统的粘贴快捷键。无论使用哪种方法，理解Robot的工作原理（模拟物理按键），处理好窗口焦点，并加入适当的延迟，是确保模拟输入成功的关键。虽然Robot。
POI从入门到上手(三)-轻松完成EasyExcel使用,完成Excel导入导出.
个人开发经验记事本在此！穿梭于代码世界，积累下满满实战心得。于我而言，开发不仅是技术的打磨，更是经验的沉淀。
05-01 647
 EasyExcel 是阿里巴巴开源的一个基于 Java 的简单、省内存的读写 Excel 工具。在处理大文件时，它能极大地减少内存占用，并且使用起来相对简单。
Linux 服务管理两种方式service和systemctl
lza20001103的博客
04-29 2011
Linux 服务管理两种方式service和systemctl
Spring框架allow-bean-definition-overriding详细解释
zwh1zwh的博客
04-28 555
Bean@Bean// 覆盖Config1的Bean​默认行为​：启动失败，抛出。​开启覆盖后​：容器中最终注册的是。
Number.isInteger()判断一个数值是否为整数报错
ABCAA1024的博客
04-30 837
NumberUtil.isInteger(String str) 实际上是判断这个字符串是否可以被 安全地解析为 Java 的 Integer 类型（即 32 位有符号整数）。NumberUtil.isInteger(“13787870101”) 返回 false，是因为它超出 Integer 的最大范围，而不是因为它不是纯数字。
MyBatis 类型处理器（TypeHandler）注册与映射机制：JsonListTypeHandler和JsonListTypeHandler注册时机
2301_76541209的博客
04-27 1411
下面几种机制会让你的最新版本的 MyBatis-Plus starter 会把类路径下所有带这类注解的自动注册进，所以即使你不在里再手动，MyBatis-Plus 启动时也会把它们扫描进来。如果你的实体里写了那 MyBatis 在构建映射的时候会直接 new 这个来处理该字段，不会再走默认的。就算真没有任何自定义 Handler，JDBC 驱动也会把你传进去的字符串（比如你在 Mapper XML 里写#{skills}，skills.toString() 恰好是["a","b"]
JVM的内存管理、垃圾回收、类加载和参数调优
andrew_1219的博客
04-29 2038
在面试中通常会考察JVM判断候选人的技术热情，对于Javaer还是比较重要的，整理一下JVM相关的知识点，包括JVM的内存管理、垃圾回收、类加载机制、JVM调优参数
ruoyi-plus Spring Boot + MyBatis 中 BaseEntity 的设计与动态查询实践
最新发布
字节叔叔
05-01 91
通过在BaseEntity中引入和params，我们实现了灵活的动态查询能力，在开发中极大简化了接口参数结构与查询逻辑。同时，也提升了系统的可维护性与扩展性，是开发大型后台系统中常用的技巧之一。如果你正在构建一个基于 Spring Boot + MyBatis 的后台管理系统，不妨考虑将这两个字段纳入你的BaseEntity设计中。
ConcurrentHashMap实现线程安全的原理结合源码分析
04-07
ConcurrentHashMap是线程安全的哈希表实现，它的线程安全是基于分段锁的思想实现的。在ConcurrentHashMap中，哈希表被分成了多个Segment，每个Segment都是一个独立的哈希表，它们之间是互相独立的，可以并发地进行操作。 每个Segment内部都有一个ReentrantLock锁，用于保护这个Segment中的数据结构。在进行put、get等操作时，会先根据key的hash值找到对应的Segment，然后再在这个Segment中进行操作，这样就避免了多个线程对同一个Segment进行操作时的竞争。 同时，ConcurrentHashMap也通过Unsafe类提供的CAS操作，实现了对哈希表中的元素的并发访问。在ConcurrentHashMap中，节点的插入、删除、替换等操作都是通过CAS操作实现的，这样就避免了多个线程对同一个节点进行操作时的竞争。 结合源码分析，我们可以看到ConcurrentHashMap中的put、get等操作都是在Segment中进行的，而Segment中的put、get等操作都是在ReentrantLock锁的保护下进行的。同时，在进行节点操作时，ConcurrentHashMap也使用了CAS操作来保证并发访问的安全。 总的来说，ConcurrentHashMap的线程安全是通过分段锁和CAS操作来实现的，它能够支持高并发的访问，并且在保证线程安全的同时，也保证了操作的高效性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值