9张图深入剖析ConcurrentHashMap!

ConcurrentHashMap介绍 ConcurrentHashMap从JDK1.5开始随java.util.concurrent包一起引入JDK中,主要为了解决HashMap线程不安全和HashTable效率不高的问题。 阅读详情

前言

在日常的开发中,我们经常使用key-value键值对的HashMap,其使用哈希表实现,用空间换取时间,提升查询性能

但在多线程的并发场景中,HashMap并不是线程安全的

如果想使用线程安全的,可以使用ConcurrentHashMap、HashTable、Collections.synchronizedMap等

但由于后面二者使用synchronized的粒度太大,因此一般不使用,而使用并发包中的ConcurrentHashMap

在ConcurrentHashMap中,使用volatile保证内存可见性,使得读场景下不需要“加锁”保证原子性

在写场景下使用CAS+synchronized,synchronized只锁哈希表某个索引位置上的首节点,相当于细粒度加锁,增大并发性能

本篇文章将从ConcurrentHashMap的使用,读、写、扩容的实现原理,设计思想等方面进行剖析

使用ConcurrentHashMap

ConcurrentHashMap是并发场景下线程安全的Map,可以在并发场景下查询存储K、V键值对

不可变对象是绝对线程安全的,无论外界如何使用,都线程安全

ConcurrentHashMap并不是绝对线程安全的,只提供方法的线程安全,如果在外层使用错误依旧会导致线程不安全

来看下面的案例,使用value存储自增调用次数,开启10个线程每个执行100次,最终结果应该是1000次,但错误的使用导致不足1000


    public void test() {
//        Map<String, Integer> map = new HashMap(16);
        Map<String, Integer> map = new ConcurrentHashMap(16);

        String key = "key";
        CountDownLatch countDownLatch = new CountDownLatch(10);


        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                for (int j = 0; j < 100; j++) {
                    incr(map, key);
//                    incrCompute(map, key);
                }
                countDownLatch.countDown();
            }).start();
        }

        try {
            //阻塞到线程跑完
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //1000不到
        System.out.println(map.get(key));
    }

	private void incr(Map<String, Integer> map, String key) {
        map.put(key, map.getOrDefault(key, 0) + 1);
    }

在自增方法incr中,先进行读操作,再计算,最后进行写操作,这种复合操作没有保证原子性,导致最终所有结果累加一定不为1000

正确的使用方式是使用JDK8提供的默认方法compute

ConcurrentHashMap实现compute的原理是在put中使用同步手段后再进行计算

	private void incrCompute(Map<String, Integer> map, String key) {
        map.compute(key, (k, v) -> Objects.isNull(v) ? 1 : v + 1);
    }

数据结构

与HashMap类似,使用哈希表+链表/红黑树实现

哈希表

哈希表的实现由数组构成,当发生哈希冲突(哈希算法得到同一索引)时使用链地址法构建成链表

image.png

当链表上的节点太长,遍历寻找开销大,超过阈值时(链表节点超过8个、哈希表长度大于64),树化成红黑树减少遍历寻找开销,时间复杂度从O(n)优化为(log n)

image.png

ConcurrentHashMap由Node数组构成,在扩容时会存在新旧两个哈希表:table、nextTable

public class ConcurrentHashMap<K,V> extends AbstractMap<K,V>
    implements ConcurrentMap<K,V>, Serializable {	
	//哈希表 node数组
	transient volatile Node<K,V>[] table;
    
    //扩容时为了兼容读写,会存在两个哈希表,这个是新哈希表
    private transient volatile Node<K,V>[] nextTable;
    
    // 默认为 0
    // 当初始化时, 为 -1
    // 当扩容时, 为 -(1 + 扩容线程数)
    // 当初始化或扩容完成后,为 下一次的扩容的阈值大小
    private transient volatile int sizeCtl;
    
    //扩容时 用于指定迁移区间的下标
    private transient volatile int transferIndex;
    
    //统计每个哈希槽中的元素数量
    private transient volatile CounterCell[] counterCells;
}
节点

Node用于实现哈希表数组的节点和发生哈希冲突时,构建成链表的节点

//实现哈希表的节点,数组和链表时使用
static class Node<K,V> implements Map.Entry<K,V> {
    //节点哈希值
	final int hash;
	final K key;
	volatile V val;
    //作为链表时的 后续指针 
	volatile Node<K,V> next;    	
}

// 扩容时如果某个 bin 迁移完毕, 用 ForwardingNode 作为旧 table bin 的头结点
static final class ForwardingNode<K,V> extends Node<K,V> {}

// 用在 compute 以及 computeIfAbsent 时, 用来占位, 计算完成后替换为普通 Node
static final class ReservationNode<K,V> extends Node<K,V> {}

// 作为 treebin 的头节点, 存储 root 和 first
static final class TreeBin<K,V> extends Node<K,V> {}

// 作为 treebin 的节点, 存储 parent, left, right
static final class TreeNode<K,V> extends Node<K,V> {}

节点哈希值

//转发节点
static final int MOVED     = -1;
//红黑树在数组中的节点
static final int TREEBIN   = -2;
//占位节点
static final int RESERVED  = -3;

转发节点:继承Node,用于扩容时设置在旧哈希表某索引的首节点,遇到转发节点要去新哈希表中寻找

static final class ForwardingNode<K,V> extends Node<K,V> {
    	//新哈希表
        final Node<K,V>[] nextTable;
    	
        ForwardingNode(Node<K,V>[] tab) {
            //哈希值设置为-1
            super(MOVED, null, null, null);
            this.nextTable = tab;
        }
}

红黑树在数组中的节点 TreeBin:继承Node,first指向红黑树的首节点

static final class TreeBin<K,V> extends Node<K,V> {
        TreeNode<K,V> root;
    	//红黑树首节点
        volatile TreeNode<K,V> first;
}    

红黑树节点TreeNode 

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;
}

占位节点:继承Node,需要计算时(使用computer方法),先使用占位节点占位,计算完再构建节点取代占位节点

	static final class ReservationNode<K,V> extends Node<K,V> {
        ReservationNode() {
            super(RESERVED, null, null, null);
        }

        Node<K,V> find(int h, Object k) {
            return null;
        }
    }

实现原理

构造

在构造时会检查入参,然后根据需要存储的数据容量、负载因子计算哈希表容量,最后将哈希表容量调整成2次幂

构造时并不会初始化,而是等到使用再进行创建(懒加载)

	public ConcurrentHashMap(int initialCapacity,
                             float loadFactor, int concurrencyLevel) {
        //检查负载因子、初始容量
        if (!(loadFactor > 0.0f) || initialCapacity < 0 || concurrencyLevel <= 0)
            throw new IllegalArgumentException();
        
        //concurrencyLevel:1
        if (initialCapacity < concurrencyLevel)   // Use at least as many bins
            initialCapacity = concurrencyLevel;   // as estimated threads
        //计算大小 = 容量/负载因子 向上取整
        long size = (long)(1.0 + (long)initialCapacity / loadFactor);
        //如果超过最大值就使用最大值 
        //tableSizeFor 将大小调整为2次幂
        int cap = (size >= (long)MAXIMUM_CAPACITY) ?
            MAXIMUM_CAPACITY : tableSizeFor((int)size);
        
        //设置容量
        this.sizeCtl = cap;
    }
读-get

读场景使用volatile保证可见性,即使其他线程修改也是可见的,不用使用其他手段保证同步

读操作需要在哈希表中寻找元素,经过扰动算法打乱哈希值,再使用哈希值通过哈希算法得到索引,根据索引上的首节点分为多种情况处理

  1. 扰动算法将哈希值充分打乱(避免造成太多的哈希冲突),符号位&0保证结果正数

    int h = spread(key.hashCode())

    扰动算法:哈希值高低16位异或运算

    经过扰动算法后,&HASH_BITS = 0x7fffffff (011111...),符号位为0保证结果为正数

    负数的哈希值表示特殊的作用,比如:转发节点、树的首节点、占位节点等

	static final int spread(int h) {
        return (h ^ (h >>> 16)) & HASH_BITS;
    }
  1. 使用打乱的哈希值经过哈希算法得到数组中的索引(下标)

    n 为哈希表长度:(n = tab.length)

    (e = tabAt(tab, (n - 1) & h)

    h为计算后的哈希值,哈希值%(哈希表长度-1) 就能求出索引位置

    为了性能提升,规定哈希表长度为2的n次幂,哈希表长度二进制一定是1000....,而(n-1)的二进制一定是0111...

    因此(n - 1) & h计算索引,进行与运算的结果一定在0~n-1之间 使用位运算提升性能

  2. 得到数组上的节点后,需要进行比较

    找到哈希表上的首个节点后,进行比较key 查看是否是当前节点

    比较规则:先对哈希值进行比较,如果对象哈希值相同,那么可能是同一个对象,还需要比较key(==与equals),如果哈希值都不相同,那么肯定不是同一个对象

    先比较哈希值的好处就是提升查找性能,如果直接使用equals 可能时间复杂度会上升(比如String的equals)

  3. 使用链地址法解决哈希冲突,因此找到节点后可能遍历链表或树;由于哈希表存在扩容,也可能要去新节点上寻找

    4.1 首节点比较成功,直接返回

    4.2 首节点哈希值为负,说明该节点是特殊情况的:转发节点、树的首节点 、计算的预订占位节点

    • 如果是转发节点,正在扩容则去新数组上找
    • 如果是TreeBin则去红黑树中寻找
    • 如果是占位节点 直接返回空

    4.3 遍历该链表依次比较

get代码

public V get(Object key) {
    Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
    //1.spread:扰动算法 + 让key的哈希值不能为负数,因为负数哈希值代表红黑树或ForwardingNode
    int h = spread(key.hashCode());
    //2.(n - 1) & h:下标、索引 实际上就是数组长度模哈希值 位运算效率更高
    //e:哈希表中对应索引位置上的节点
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (e = tabAt(tab, (n - 1) & h)) != null) {
        //3.如果哈希值相等,说明可能找到,再比较key
        if ((eh = e.hash) == h) {
            //4.1 key相等说明找到 返回
            if ((ek = e.key) == key || (ek != null && key.equals(ek)))
                return e.val;
        }
        //4.2 首节点哈希值为负,说明该节点是转发节点,当前正在扩容则去新数组上找
        else if (eh < 0)
            return (p = e.find(h, key)) != null ? p.val : null;
        
        //4.3 遍历该链表,能找到就返回值,不能返回null
        while ((e = e.next) != null) {
            if (e.hash == h &&
                ((ek = e.key) == key || (ek != null && key.equals(ek))))
                return e.val;
        }
    }
    return null;
}
写-put

添加元素时,使用CAS+synchronized(只锁住哈希表中某个首节点)的同步方式保证原子性

  1. 获取哈希值:扰动算法+确保哈希值为正数
  2. 哈希表为空,CAS保证一个线程初始化
	private final Node<K,V>[] initTable() {
        Node<K,V>[] tab; int sc;
        while ((tab = table) == null || tab.length == 0) {
            //小于0 说明其他线程在初始化 让出CPU时间片 后续初始化完退出
            if ((sc = sizeCtl) < 0)
                Thread.yield(); 
            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;
    }
  1. 将哈希值通过哈希算法获取索引上的节点 f = tabAt(tab, i = (n - 1) & hash)

  2. 根据不同情况进行处理

    • 4.1 首节点为空时,直接CAS往索引位置添加节点 casTabAt(tab, i, null,new Node<K,V>(hash, key, value, null))

      image.png

    • 4.2 首节点hash为MOVED -1时,表示该节点是转发节点,说明正在扩容,帮助扩容

    • 4.3 首节点加锁

      • 4.3.1 遍历链表寻找并添加/覆盖

        image.png

      • 4.3.2 遍历树寻找并添加/覆盖

  3. addCount统计每个节点上的数据,并检查扩容

put代码

//onlyIfAbsent为true时,如果原来有k,v则这次不会覆盖
final V putVal(K key, V value, boolean onlyIfAbsent) {
    if (key == null || value == null) throw new NullPointerException();
    //1.获取哈希值:扰动算法+确保哈希值为正数
    int hash = spread(key.hashCode());
    int binCount = 0;
    //乐观锁思想 CSA+失败重试
    for (Node<K,V>[] tab = table;;) {
        Node<K,V> f; int n, i, fh;
        //2.哈希表为空 CAS保证只有一个线程初始化
        if (tab == null || (n = tab.length) == 0)
            tab = initTable();
        //3. 哈希算法求得索引找到索引上的首节点
        //4.1 节点为空时,直接CAS构建节点
        else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
            if (casTabAt(tab, i, null,
                         new Node<K,V>(hash, key, value, null)))
                break;                   // no lock when adding to empty bin
        }
        //4.2 索引首节点hash 为MOVED 说明该节点是转发节点,当前正在扩容,去帮助扩容
        else if ((fh = f.hash) == MOVED)
            tab = helpTransfer(tab, f);
        else {
            V oldVal = null;
            //4.3 首节点 加锁
            synchronized (f) {
                //首节点没变
                if (tabAt(tab, i) == f) {
                    //首节点哈希值大于等于0 说明节点是链表上的节点  
                    //4.3.1 遍历链表寻找然后添加/覆盖
                    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;
                                //onlyIfAbsent为false允许覆盖(使用xxIfAbsent方法时,有值就不覆盖)
                                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;
                            }
                        }
                    }
                    //如果是红黑树首节点,则找到对应节点再覆盖
                    //4.3.2 遍历树寻找然后添加/覆盖
                    else if (f instanceof TreeBin) {
                        Node<K,V> p;
                        binCount = 2;
                        //如果是添加返回null,返回不是null则出来添加
                        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)
                    //链表上的节点超过TREEIFY_THRESHOLD 8个(不算首节点) 并且 数组长度超过64才树化,否则扩容
                    treeifyBin(tab, i);
                if (oldVal != null)
                    return oldVal;
                break;
            }
        }
    }
    //5.添加计数,用于统计元素(添加节点的情况)
    addCount(1L, binCount);
    return null;
}
扩容

为了避免频繁发生哈希冲突,当哈希表中的元素数量 / 哈希表长度 超过负载因子时,进行扩容(增大哈希表的长度)

一般来说扩容都是增大哈希表长度的2倍,比如从32到64保证长度是2次幂;如果扩容长度达到整型上限则使用整型最大值

当发生扩容时,需要将数组中每个槽里的链表或树迁移到新数组中

如果处理器是多核,那么这个迁移的操作并不是一个线程单独完成的,而是会让其他线程也来帮助迁移

在迁移时让每个线程从右往左的每次迁移多个槽,迁移完再判断是否全部迁移完,如果没迁移完则继续循环迁移

扩容操作主要在transfer方法中,扩容主要在三个场景下:

  1. addCount:添加完节点增加计数检查扩容
  2. helpTransfer:线程put时发现正在迁移,来帮忙扩容
  3. tryPresize:尝试调整容量(批量添加putAll,树化数组长度没超过64时treeifyBin调用)

分为以下3个步骤

  1. 根据CPU核数、哈希表总长度计算每次迁移多少个槽,最小16个

  2. 新哈希表为空,说明是初始化

  3. 循环迁移

    • 3.1 分配负责迁移的区间 [bround,i](可能存在多线程同时迁移)

      image.png

    • 3.2 迁移:分为链表迁移、树迁移

      链表迁移

      1. 将链表上的节点充分散列到新哈希表的index、index+旧哈希表长度的两个下标中(与HashMap类似)

      2. 将index位置链表中的节点 (hash & 哈希表长度),结果为0的放到新数组的index位置,结果为1放到新数组index+旧哈希表长度的位置

        image.png

        比如旧哈希表长度为16,在索引3的位置上,16的二进制是10000,hash&16 => hash& 10000 ,也就是说节点哈希值第5位是0就放到新哈希表的3位置上,是1就放到新哈希表的3+16下标

      3. 使用头插法将计算结果为0构建成ln链表,为1构建成hn链表,为方便构建链表,会先寻找lastRun节点:lastRun节点及后续节点都为同一链表上的节点,方便迁移

        构建链表前先构建lastRun,比如图中lastRun e->f ,先将lastRun放到ln链表上,在遍历原始链表,遍历到a :a->e->f,遍历到b:b->a->e->f

      image.png

      1. 每迁移完一个索引位置就将转发节点设置到原哈希表对应位置,当其他线程进行读get操作时,根据转发节点来新哈希表中寻找,进行写put操作时,来帮助扩容(其他区间进行迁移)

        image.png

扩容代码

//tab 旧哈希表
//nextTab 新哈希表
private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
        //1.计算每次迁移多少个槽
        //n:哈希表长度(多少个槽)
        int n = tab.length, stride;
        //stride:每次负责迁移多少个槽
        //NCPU: CPU核数
        //如果是多核,每次迁移槽数 = 总槽数无符号右移3位(n/8)再除CPU核数  
        //每次最小迁移槽数 = MIN_TRANSFER_STRIDE = 16
        if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
            stride = MIN_TRANSFER_STRIDE; // subdivide range
    
        //2.如果新哈希表为空,说明是初始化
        if (nextTab == null) {            // initiating
            try {
                @SuppressWarnings("unchecked")
                Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n << 1];
                nextTab = nt;
            } catch (Throwable ex) {      // try to cope with OOME
                sizeCtl = Integer.MAX_VALUE;
                return;
            }
            nextTable = nextTab;
            //transferIndex用于记录 每次负责迁移的槽右区间下标,从右往左分配,起始为最右
            transferIndex = n;
        }
        //新哈希表长度
        int nextn = nextTab.length;
        //创建转发节点,转发节点一般设置在旧哈希表首节点,通过转发节点可以找到新哈希表
        ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);
        //advance:是否继续循环迁移
        boolean advance = true;
        // 
        boolean finishing = false; // to ensure sweep before committing nextTab
        //3.循环迁移
        for (int i = 0, bound = 0;;) {
            Node<K,V> f; int fh;
            //3.1 分配负责迁移的区间
            //bound为左区间 i为右区间
            while (advance) {
                int nextIndex, nextBound;
                //处理完一个槽 右区间 自减
                if (--i >= bound || finishing)
                    advance = false;
                //transferIndex<=0说明 要迁移的区间全分配完
                else if ((nextIndex = transferIndex) <= 0) {
                    i = -1;
                    advance = false;
                }
                //CAS设置本次迁移的区间,防止多线程分到相同区间
                else if (U.compareAndSwapInt
                         (this, TRANSFERINDEX, nextIndex,
                          nextBound = (nextIndex > stride ?
                                       nextIndex - stride : 0))) {
                    bound = nextBound;
                    i = nextIndex - 1;
                    advance = false;
                }
            }
            
            //3.2 迁移
            
            //3.2.1 如果右区间i不再范围,说明迁移完
            if (i < 0 || i >= n || i + n >= nextn) {
                int sc;
                //如果完成迁移,设置哈希表、数量
                if (finishing) {
                    nextTable = null;
                    table = nextTab;
                    sizeCtl = (n << 1) - (n >>> 1);
                    return;
                }
                //CAS 将sizeCtl数量-1 表示 一个线程迁移完成 
                if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
                    //如果不是最后一条线程直接返回
                    if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)
                        return;
                    //是最后一条线程设置finishing为true  后面再循环 去设置哈希表、数量等操作
                    finishing = advance = true;
                    i = n; // recheck before commit
                }
            }
            //3.2.2 如果旧哈希表i位置节点为空就CAS设置成转发节点
            else if ((f = tabAt(tab, i)) == null)
                advance = casTabAt(tab, i, null, fwd);
            //3.2.3 如果旧哈希表该位置首节点是转发节点,说明其他线程已处理,重新循环
            else if ((fh = f.hash) == MOVED)
                advance = true; // already processed
            else {
                //3.2.4 对首节点加锁 迁移
                synchronized (f) {
                    if (tabAt(tab, i) == f) {
                        Node<K,V> ln, hn;
                        //3.2.4.1 链表迁移
                        //首节点哈希值大于等于0 说明 是链表节点
                        if (fh >= 0) {
                            int runBit = fh & n;
                            Node<K,V> lastRun = f;
                            //寻找lastRun节点 
                            for (Node<K,V> p = f.next; p != null; p = p.next) {
                                int b = p.hash & n;
                                if (b != runBit) {
                                    runBit = b;
                                    lastRun = p;
                                }
                            }
                            //如果最后一次计算值是0
                            //lastRun节点以及后续节点计算值都是0构建成ln链表 否则 都是1构建成hn链表
                            if (runBit == 0) {
                                ln = lastRun;
                                hn = null;
                            }
                            else {
                                hn = lastRun;
                                ln = null;
                            }
                            
                            //遍历构建ln、hn链表 (头插)
                            for (Node<K,V> p = f; p != lastRun; p = p.next) {
                                int ph = p.hash; K pk = p.key; V pv = p.val;
                                //头插:Node构造第四个参数是后继节点
                                if ((ph & n) == 0)
                                    ln = new Node<K,V>(ph, pk, pv, ln);
                                else
                                    hn = new Node<K,V>(ph, pk, pv, hn);
                            }
                            //设置ln链表到i位置
                            setTabAt(nextTab, i, ln);
                            //设置hn链表到i+n位置
                            setTabAt(nextTab, i + n, hn);
                            //设置转发节点
                            setTabAt(tab, i, fwd);
                            advance = true;
                        }
                        //3.2.4.2 树迁移
                        else if (f instanceof TreeBin) {
                            TreeBin<K,V> t = (TreeBin<K,V>)f;
                            TreeNode<K,V> lo = null, loTail = null;
                            TreeNode<K,V> hi = null, hiTail = null;
                            int lc = 0, hc = 0;
                            for (Node<K,V> e = t.first; e != null; e = e.next) {
                                int h = e.hash;
                                TreeNode<K,V> p = new TreeNode<K,V>
                                    (h, e.key, e.val, null, null);
                                if ((h & n) == 0) {
                                    if ((p.prev = loTail) == null)
                                        lo = p;
                                    else
                                        loTail.next = p;
                                    loTail = p;
                                    ++lc;
                                }
                                else {
                                    if ((p.prev = hiTail) == null)
                                        hi = p;
                                    else
                                        hiTail.next = p;
                                    hiTail = p;
                                    ++hc;
                                }
                            }
                            ln = (lc <= UNTREEIFY_THRESHOLD) ? untreeify(lo) :
                                (hc != 0) ? new TreeBin<K,V>(lo) : t;
                            hn = (hc <= UNTREEIFY_THRESHOLD) ? untreeify(hi) :
                                (lc != 0) ? new TreeBin<K,V>(hi) : t;
                            setTabAt(nextTab, i, ln);
                            setTabAt(nextTab, i + n, hn);
                            setTabAt(tab, i, fwd);
                            advance = true;
                        }
                    }
                }
            }
        }
    }

实现原理并没有对红黑树进行太多描述,一方面是红黑树的概念太多,另一方面是我忘的差不多了(已经老了,不像大学那样可以手写红黑树了)

还有一方面是:我认为只需要知道使用红黑树的好处就足够,而且工作中也不常用,就算死扣红黑树要怎么变色、左旋、右旋去满足红黑树的条件也没什么意义,感兴趣的同学去学习就好了

迭代器

ConcurrentHashMap中的迭代器是弱一致性,在获取时使用记录的哈希表重新构建新对象

Entry迭代器:

public Iterator<Map.Entry<K,V>> iterator() {
    ConcurrentHashMap<K,V> m = map;
    Node<K,V>[] t;
    int f = (t = m.table) == null ? 0 : t.length;
    return new EntryIterator<K,V>(t, f, 0, f, m);
}

key迭代器

public Enumeration<K> keys() {
    Node<K,V>[] t;
    int f = (t = table) == null ? 0 : t.length;
    return new KeyIterator<K,V>(t, f, 0, f, this);
}

value迭代器

public Enumeration<V> elements() {
    Node<K,V>[] t;
    int f = (t = table) == null ? 0 : t.length;
    return new ValueIterator<K,V>(t, f, 0, f, this);
}

总结

ConcurrentHashMap使用哈希表的数据结构,当发生哈希冲突时,使用链地址法解决,将哈希到同一索引的节点构建成链表,当数据量达到一定阈值,会将链表转化为红黑树

ConcurrentHashMap使用volatile修饰存储数据,使得在读场景下对其他线程的修改可见,不需要使用同步机制,使用CAS与synchronzied保证写场景下的原子性

在get查询数据时,先将key的哈希值通过扰动算法(高低16位异或)并保证结果为正数(与上符号位0),再与上哈希表长度-1求出索引值,找到索引后再根据不同情况查找(比较先判断哈希值,相等再判断key)

在put添加/覆盖数据时,也是先通过扰动算法和哈希求出索引位置,在根据不同情况查找,找到则覆盖,找不到则替换

在需要扩容时,会为线程安排需要迁移的槽区间,当其他线程进行put时也会来帮忙迁移,每次线程迁移完一个槽,会设置转发节点到原哈希表中,这样有线程查询就可以通过转发节点来新哈希表中查找,当迁移完所有槽时留一个线程来设置哈希表、数量等

迭代器使用的是弱一致性,在获取迭代器时通过哈希表去构建新的对象

ConcurrentHashMap 只保证相对线程安全,不能保证绝对线程安全,如果需要进行一系列操作时,要正确的去使用

ConcurrentHashMap:使用方法和底层原理详解 ConcurrentHashMap是Java集合框架中的一个线程安全的哈希表实现,它提供了比Hashtable和同步的HashMap更高的并发性能。ConcurrentHashMap在JDK 1.5中引入,通过采用分段锁的方式实现了高效的并发访问。它可以在保证线程安全的同时,提供较高的并发性能,因此是多线程环境下使用频率较高的数据结构之一。 阅读详情

相关推荐

ConcurrentHashMap1.7深度解析

ConcurrentHashMap1.7深度解析 1.ConcurrentHashMap原型图 1.1 总结 1.1.1 分段锁定 从原型图我们可以看出concurrentHashMap1.7是采用的分段锁定,也就是对每个segment进行上锁,简单来说,ConcurrentHashMap的锁的颗粒度会在每个分段(segment)上。 不同的Segment:读读不需要互斥,读写不需要互斥 相同的Segment:读读不需要互斥,读写则需要互斥 .

LuckFairyLuckBaby的博客 1689

ConcurrentHashMap详解

文章目录spread()方法putVal()方法initTable()方法tryPresize()tableSizeFor()resizeStamp()transfer()总结compute()addCount() 计算成员数量sumCount()fullAddCount()资源锁sizeCtl其它节点类型forwarding节点ReservationNode节点 spread()方法 作用:用于获取槽位值 static final int spread(int h) { //h为k

唐芬奇的博客 8万+

Java并发进阶系列:深度讨论官方关于jdk1.8ConcurrentHashMap的computeIfAbsent源代码修复逻辑

在文章中《深度解析官方关于jdk1.8的resizeStamp的bug处理过程》,我们讨论关于CHM的核心设计——resizeStam需要修复的处理过程,本文再次基于openJDK的bugs讨论组提出的CHM源代码另外一个会造成死循环的bug,默认读者已经掌握CHM的核心源代码实现,否则无法从本文的讨论中获益。文章前部分先把computeIfAbsent的bug成因分析清楚,再来介绍官网ConcurrentHashMap.computeIfAbsent stuck in an endless loop的讨论

pysense的博客 998

Map 综述(三):彻头彻尾理解 ConcurrentHashMap

ConcurrentHashMap是J.U.C的重要成员,它是HashMap的一个线程安全的版本。在默认理想状态下,ConcurrentHashMap可以支持16个线程执行并发写操作及任意数量线程的读操作。本文将结合Java内存模型和JDK源代码,剖析其高并发的具体实现机制,包括在JDK中的定义和结构、并发存取、重哈希和跨段操作,并着重剖析了ConcurrentHashMap读操作不需要加锁的内在奥秘和原理。

Rico's Blogs 14万+

Spring Authorization Server自定义密码模式:突破标准OAuth2限制,实现MFA与复杂业务集成

OAuth 2.0授权框架是构建现代应用安全体系的基石,其密码模式(Resource Owner Password Credentials Grant)提供了一种直接的资源所有者凭证交换令牌的机制。该模式的核心原理是客户端收集用户密码并直接向授权服务器请求访问令牌,适用于受信任的客户端场景。在技术价值上,它简化了某些传统应用的OAuth集成流程。然而,标准实现往往难以满足复杂的现实业务需求,例如需要集成多因素认证(MFA)、对接外部LDAP目录服务或执行自定义密码加密校验等场景。Spring Authori

weixin_34302561的博客 438

智能座舱架构与芯片 - (3) 硬件篇 上

在了解智能座舱的基本架构之后,我们有必要针对智能座舱域的硬件平台,软件平台,SOC等进行逐一介绍。从它们的整体结构中去认识最新的智能座舱组成部件,以及主要功能等。如上图,是中央计算-区域控制架构下的智能座舱硬件平台框架图,其中,智能座舱控制器CDC挂载在以太网交换机上,与其他车控域VDC,自驾域ADC,网联设备5G+V2X等通过以太网实现数据交互。而智能座舱域的外部硬件设备还包含有连接子系统音频子系统摄像头子系统显示子系统存储子系统功能安全子系统等。

joanna_xiao的博客 2407

9张图深入剖析ConcurrentHashMap

在日常的开发中,我们经常使用key-value键值对的HashMap,其使用哈希表实现,用空间换取时间,提升查询性能但在多线程的并发场景中,HashMap并不是线程安全的如果想使用线程安全的,可以使用ConcurrentHashMap、HashTable、Collections.synchronizedMap等但由于后面二者使用synchronized的粒度太大,因此一般不使用,而使用并发包中的ConcurrentHashMap。

关注菜菜的后端私房菜,获取更多技术干货~ 911

揭秘 Chat Template 如何驱动 AI Agent?以Qwen3为例详解LLM的聊天模板

bos_token: null (没有使用特殊的文档开始符)eos_token<|im_end|>(作为每个对话回合的结束符)pad_token: 对话回合开始<|im_end|>: 对话回合结束非特殊但关键的控制 Token (在词汇表中定义): 包裹模型生成的工具调用请求。: 包裹外部工具返回的执行结果。<think></think>: 包裹模型的内部思考或推理过程。

ljp1919的专栏 1355

9-HashMap及ConcurrentHashMap底层原理剖析

【代码】9-HashMap及ConcurrentHashMap底层原理剖析。

kongxubihai的博客 445

PNG编解码算法详解

1.PNG介绍 PNG是便携式网络图型( Portable Network Graphics)的缩写,由于PNG带有透明通道,无损压缩,可提升设计元素的呈现效果,因此设计上对PNG情有独钟,广泛的运用在设计、游戏、网页、app开发里,实际使用上由于存在很多误区,导致被滥用,这里对之前学习png的心得做个整理。 首先,PNG和诞生跟GIF格式有较大关系,这中间有很多趣事,可自行查阅。PNG的压缩过程是完全无损的,压缩过的文件可以准确的还原出原图,可封装多种pixfmt格式的数据,并且是一种可扩展的封装格式,

lemonHe的博客 1万+

常用的串口通信工具MobaXterm、Bus Hound、SScom等

本文介绍了四种PC端串口通信工具的功能和使用方法:MobaXterm支持SSH、FTP、串口等多种协议;Bus Hound用于监控CAN和串口数据;SScom专为串口和网口通信设计;ScriptCommunicator可进行串口通信并绘制波形图。每种工具都有详细的操作步骤图示,包括参数设置、数据监控等关键功能,并提供了官方和个人下载地址。这些工具各有特点,适用于不同的串口通信和数据分析场景。

sanqima的专栏 2537

JDK9 ConcurrentHashMap实现原理(一)

文章目录JDK9 ConcurrentHashMap实现原理(一)数据结构相关知识点volitale JDK9 ConcurrentHashMap实现原理(一) 数据结构 JDK1.7中采用Segment + HashEntry的方式进行实现.使用ReentrantLock实现加锁操作。 JDK1.8中放弃了Segment臃肿的设计,取而代之的是采用Node + CAS + Synchroni...

皮蛋瘦肉的博客 599

27、超声成像技术与原理全面解析

本博客全面解析了超声成像技术与原理,涵盖声学材料特性、超声成像系统的基本概念与组成、关键技术如多普勒和聚焦技术、超声换能器的设计与原理、图像处理方法、系统校准与质量控制,以及超声成像的应用领域和发展趋势。旨在为医学诊断、工业检测和海洋声学等领域的研究人员和工程师提供深入的技术参考和指导。

z2a3b4c5d的博客 503

HashMap以及concurrentHashMap剖析

文章目录HashMap红黑树扩容HashMap在多线程下的问题concurrentHashMap为什么concurrentHashMap是弱一致性的? 在JDK1.8之后HashMap以及concurrentHashMap的实现与JDK1.7中非常不同,JDK1.8对此进行了很大的优化,尤其是coucurrentHashMap。在1.8中,concurrentHashMap的结构与HashMap已经非常的相似了,我们先来看看HashMap。 HashMap HashMap的主干是一个Entry数组,一个En

weixin_45003125的博客 691

ChangeMamba训练调试

此仓库的代码是在 Linux 系统下运行的。我们尚未测试是否能在其他操作系统下运行。 首先需要安装VMama仓库。以下安装顺序取自VMama仓库。克隆该版本库并导航至项目目录: 建议设置 conda 环境并通过 pip 安装依赖项。使用以下命令设置环境: 创建并激活新的 conda 环境 安装依赖项 检测和分割任务的依赖库(在 VMamba 中为可选项) 二、下载预训练权重 另外,请下载VMamba-Tiny, VMamba-Small, and VMamba-Base在ImageNet上的预训练权重并把它

hanfeng5268的博客 578

西南科技大学模拟电子技术实验二(二极管特性测试及其应用电路)预习报告

3、用二极管正向虚拟IV仪测出数据,并记录数据于虚表3和虚表4。1、按照指导书multisim仿真软件上画出三种模型电路图,1、按照指导书multisim仿真软件上画出三种模型电路图,1、按照指导书multisim仿真软件上画出三种模型电路图,表6 二极管三种模型参数测试表(电源电压=1.2V)2、用万用表测出数据,并记录数据于虚表1和虚表2。2、用万用表测出数据,并记录数据于虚表5和虚表6。表5 二极管三种模型参数测试表(电源电压=12V)二极管三种模型参数测试表(电源电压=12V)

Welcome To My6n Blog 4086

HashMap与ConcurrentHashMap深度解析

HashMap和ConcurrentHashMap是Java中两种重要的Map实现。HashMap采用数组+链表+红黑树结构,通过哈希函数快速定位元素,但非线程安全;ConcurrentHashMap通过分段锁或CAS实现线程安全,适合高并发场景。HashMap在JDK8中引入红黑树优化链表查询,扩容时容量翻倍。理解二者的数据结构、哈希机制和并发策略,对编写高效Java程序至关重要。

J_liaty的博客 1068

SAP B1中文培訓教材_SDK

公司内部培训资料,对开发工具 ,DIAPI, UIAPI,Add-ON有详细解说

从幕后揭秘:HashMap 与 ConcurrentHashMap 的全面演进与 JDK8 优化

本文将系统回顾 Java 标准库中两大哈希表实现——HashMap 与 ConcurrentHashMap——从 JDK 1.2 到 JDK17 的演化历程,结合 Java 内存模型原理,深入剖析其在不同版本下的底层设计以及算法优化;并通过汇编级别分析、性能对比、生产案例和生态对比,全面呈现哈希表在高并发、大数据量场景中的实践与调优;最后展望容器在 Valhalla、Project Loom 等未来特性中的前景。地点HashMap 吞吐 (ops/s)

lssffy的博客 1807

LinePhone3.2.7(android端最新版本) sip客户端

SIP客户端For android:LinePhone3.2.7(最新版本),官网地址:http://www.linphone.org/

怀旧版电脑GBC模拟器

再现原版GBC掌机的界面,电脑运行连游戏界面都一样大小,很怀旧,很真实,(英文版)强烈推荐,很小的文件,很难才找到的。

震惊!ConcurrentHashMap里面也有死循环,作者留下的“彩蛋”了解一下?

JDK BUG这篇文章,聊一下我最近才知道的一个关于 JDK 8 的 BUG 吧。首先说一下我是怎么发现这个 BUG 的呢?大家都知道我对 Dubbo 有一定的关注,前段时间 Dubbo...

HollisChuang's Blog 1019

OV9734 DATASHEET,完整规格书

OV9734完整规格书,包括电气参数,尺寸规格,寄存器配置表等

CS-Notes Java 容器指南:ArrayList、HashMap、ConcurrentHashMap 的选型标准与 JDK 源码级实现剖析

本文基于 CS-Notes 仓库的 Java 容器 笔记整理扩展,系统梳理 Java 容器框架中 Collection 与 Map 两大体系的实现选型依据(时间复杂度、有序性、线程安全三维度),并深入到 JDK 源码层面剖析 ArrayList 扩容与 Fail-Fast、HashMap 拉链法与桶下标的位运算优化、ConcurrentHashMap 分段锁与 size 无锁统计、LinkedHa

gitblog_01060的博客 748

ConcurrentHashMap——put核心逻辑

Map Map篇之ConcurrentHashMap——put的核心逻辑 ConcurrentHashMap之put的核心逻辑原理解析图示Map前言一、ConcurrentHashMap之put的核心逻辑原理解析ConcurrentHashMap流程二、ConcurrentHashMap之put的核心逻辑原理解析剖析图总结 前言 ConcurrentHashMap之put的核心逻辑原理解析图示。 一、ConcurrentHashMap之put的核心逻辑原理解析 ConcurrentHashMap流

weixin_42397937的博客 7570

ConcurrentHashMap一些问题总结

本文介绍了ConcurrentHashMap的put操作为什么可以保证并发操作安全。方法中在判断桶位是空的时候执行CAS操作为什么能保证并发安全,不会出现类似单例模式的时候,但判断后执行的那种问题。以及他们的get方法和keySet方法有什么不同。在并发读的时候有什么问题。

onesingledog的博客 244

JDK核心源码深入剖析(synchronized和ConcurrentHashMap)

JDK核心源码深入剖析(synchronized和ConcurrentHashMap)JDK核心源码深入剖析1 同步锁synchronized追本溯源1.1 synchronized场景回顾1.2 反汇编寻找锁实现原理1.3 Monitor详解1.3.2 Monitor竞争1.3.3 Monitor释放2 并发容器线程安全应对之道2.1 并发容器总体概述2.2 并发容器数据结构与继承2.3 并发容器源码深度剖析2.3.1 并发容器成员变量2.3.2 并发容器构造器 JDK核心源码深入剖析 1 同步锁sync

m0_46690280的博客 292

ConcurrentHashMap源码剖析

ConcurrentHashMap是Java5中新增加的一个线程安全的Map集合,可以用来替代HashTable。对于ConcurrentHashMap是如何提高其效率的,可能大多人只是知道它使用了多个锁代替HashTable中的单个锁,也就是锁分离技术(Lock Stripping)。实际上,ConcurrentHashMap对提高并发方面的优化,还有一些其它的技巧在里面(比如你是否知道在g

TanZJ的博客 410

高能预警:Java ConcurrentHashMap里面也有死循环!!!

JDK BUG 这篇文章,聊一下我最近才知道的一个关于 JDK 8 的 BUG 吧。 首先说一下我是怎么发现这个 BUG 的呢? 大家都知道我对 Dubbo 有一定的关注,前段时间 Dubbo 2.7.7 发布后我看了它的更新点,就是下面这个网址: https://github.com/apache/dubbo/releases/tag/dubbo-2.7.7 其中有 Bugfixes 这一部分: 每一个我都去简单的看了一下,其他的 Bugfixes 或多或少都和 Dubbo 框架有一定的关.

一个天秤座的架构师 2万+

ConcurrentHashMap 并发原理与实战:从 JDK 1.7 分段锁到 1.8 CAS 源码剖析

在 Java 并发编程中,线程安全容器是解决多线程数据竞争的关键技术。其核心原理在于通过锁分段或 CAS 与 synchronized 组合,降低锁粒度,提升并发吞吐量。ConcurrentHashMap 作为高频使用的并发容器,在缓存、计数器等场景中技术价值显著,能有效避免 HashMap 在并发下的数据覆盖与死循环问题。理解其从 JDK 1.7 分段锁到 1.8 桶级锁的演进,以及扩容、size 计数等机制,是面试与工程实践的必修课。本文深入拆解其数据结构与关键源码,结合性能实测与避坑经验,帮助开发者彻

weixin_34174105的博客 290
上一篇: MySQL的优化利器⭐️索引条件下推,千万数据下性能提升273%
下一篇: 面试官:详细介绍一下Spring的循环依赖?
加班不秃顶
博客等级 码龄7年 1822粉丝 599原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值