ConcurrentHashMap源码分析（JDK1.8）

最新推荐文章于 2024-07-22 14:15:06 发布
最新推荐文章于 2024-07-22 14:15:06 发布
阅读量387 收藏 1
点赞数 2
分类专栏： JAVA源码学习 文章标签： java hashmap 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ji1162765575/article/details/111309612
版权

一、JDK1.8ConcurrentHashMap介绍

JDK1.8中ConcurrentHashMap底层依旧是数组+链表+红黑树，使用Synchronized+Unsafe类来保证线程安全
当需要同步时，对底层Node数组中的某个Node/TreeBin对象进行加锁
在这里插入图片描述

几个默认值

  • DEFAULT_INITIAL_CAPACITY 默认初始化容量 16
  • MAXIMUM_CAPACITY 最大容量 2的30次幂
  • LOAD_FACTOR 默认的负载因子 0.75
  • DEFAULT_CONCURRENCY_LEVEL 并发等级 16
  • TREEIFY_THRESHOLD 链表转红黑树的树化阈值（某一链表个数） 8
  • UNTREEIFY_THRESHOLD 红黑树退化成链表的阈值 6
  • MIN_TREEIFY_CAPACITY 链表转红黑树的树化阈值（map整体容量） 64
  • MIN_TRANSFER_STRIDE 扩容时转移元素的最小步长 16
  • RESIZE_STAMP_BITS sizeCtl中用于生成标记的位数，对于32位阵列，必须至少为6 默认为16
  • MAX_RESIZERS 可以协助扩容的最大线程数，默认为(1 << (32 - RESIZE_STAMP_BITS)) - 1
  • RESIZE_STAMP_SHIFT 在sizeCtl中记录大小标记的位移位 为 32 - RESIZE_STAMP_BITS
  • NCPU 当前操作系统CPU核数
  • MOVED forwarding节点的hash值，为-1，表示该节点已经扩容转移过
  • TREEBIN TreeBin对象的hash值。为-2，表示该节点是一颗红黑树对象
  • RESERVED 临时保存的hash值，为-3
  • HASH_BITS 普通节点哈希的可用位，为0x7fffffff，用于与运算，使最高位永远为0，即与后的值永远是正数

sizeCtl介绍

  • 用来控制table的初始化和扩容操作，有以下几种取值情况
  • sizeCtl为0，表示数组未初始化，且数组的初始容量为16
  • sizeCtl为-1，表示数组正在进行初始化
  • sizeCtl为正数，如果数组未初始化，则表示数组的初始容量；如果数组已经初始化，则表示数组的扩容阈值
  • sizeCtl 为 (resizeStamp(n) << RESIZE_STAMP_SHIFT) + 2)，表示当前数组只有一个线程在扩容，当有新的数组进行扩容时，在执行扩容方法前，首先要将sizeCtl加1，完成扩容并退出时会减1

二：构造器

	/** 
	* 空参构造，调用重载的构造方法
	*/
    public ConcurrentHashMap() {
    }
    /** 
	* 指定数组初始化长度
	* 传过来一个初始容量，乘以1.5以后加一
	* 对计算结果取大于等于此结果的2的次幂
	* 如 initialCapacity为16 则cap为32  initialCapacity为15 cap也为32
	* sizeCtl为数组的初始容量
	*/
	public ConcurrentHashMap(int initialCapacity) {
        if (initialCapacity < 0)
            throw new IllegalArgumentException();
        // 1.5*initialCapacity+1  之后取大于等于此数的2的次幂 
        int cap = ((initialCapacity >= (MAXIMUM_CAPACITY >>> 1)) ?
                   MAXIMUM_CAPACITY :
                   tableSizeFor(initialCapacity + (initialCapacity >>> 1) + 1)); 
        this.sizeCtl = cap; // 数组未初始化，sizeCtl表示数组的初始容量
    }
    // 指定数组初始化长度与默认负载因子
	public ConcurrentHashMap(int initialCapacity, float loadFactor) {
        this(initialCapacity, loadFactor, 1);
    }
	// 所有参数全部指定
	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; // 数组未初始化，sizeCtl表示数组的初始容量
    }
   
    // 根据已有的Map去构造
	public ConcurrentHashMap(Map<? extends K, ? extends V> m) {
        this.sizeCtl = DEFAULT_CAPACITY;
        putAll(m);
    }

三：底层数组初始化

当同时有多个线程要对底层数组进行初始化时，只允许一个线程真正进行初始化，这里使用CAS加自旋操作保证并发安全。
当一个线程正在进行初始化时会将sizeCtl置为-1，其他线程会先判断sizeCtl是否小于0，如果小于0则释放CPU执行权。

private final Node<K,V>[] initTable() {
    Node<K,V>[] tab; int sc;
    // 当底层数组为空时，自旋
    while ((tab = table) == null || tab.length == 0) {
        if ((sc = sizeCtl) < 0)
        	// sizeCtl小于0的情况有两种，一种是正在进行扩容，一种是正在进行初始化，这里是正在初始化
        	// 当一个线程进入到此条件，表示有一个其他线程正在对此数组进行初始化，那么当前线程就让出CPU的执行权，去自旋
            Thread.yield(); // lost initialization race; just spin
        else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) { // SIZECTL为0 当sizeCtl也是0时，使用CAS将其置为-1
    		// 如果CAS成功，则进行数组的初始化操作，不成功则自旋
            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 = 0.75*n 后面会赋值给sizeCtl
                    sc = n - (n >>> 2);
                }
            } finally {
            	// 数组初始化成功，sizeCtl表示扩容阈值
                sizeCtl = sc;
            }
            break;
        }
    }
    return tab;
}

四：put方法

public V put(K key, V value) {
    return putVal(key, value, false);
}
final V putVal(K key, V value, boolean onlyIfAbsent) {
	// 不允许null键和null值
    if (key == null || value == null) throw new NullPointerException();
    // 计算出一个hash值，并在方法里确保hash值一定为一个正数（通过对HASH_BITS进行按位与实现）
    int hash = spread(key.hashCode());
    int binCount = 0;
    // 死循环，满足条件会break，不满足条件则自旋，配合Unsafe类与Synchronized实现并发安全
    for (Node<K,V>[] tab = table;;) { // 
        Node<K,V> f; int n, i, fh;
        if (tab == null || (n = tab.length) == 0)
        	// 底层数组未初始化，对底层数组进行初始化操作，获得一个初始数组后继续自旋进入下一个if判断条件
            tab = initTable();
        else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) { // 这里会计算新添加的元素要放置的位置，判断该位置是否为空
        	// 如果该位置为空，使用CAS放置一个新的Node对象到该位置，成功则brerak跳出死循环，不成功则自旋
            if (casTabAt(tab, i, null,
                         new Node<K,V>(hash, key, value, null)))
                break;                   // no lock when adding to empty bin
        }
        // 如果该位置有对象了，并且该节点对象的hash值为-1.表示数组正在进行扩容，则该线程需要去协助扩容
        else if ((fh = f.hash) == MOVED)
            tab = helpTransfer(tab, f);
        // 以上条件都不满足，即底层数组存在且计算出的数组下标有值且数组没有进行扩容，则去添加/替换元素
        else {
            V oldVal = null;
            // 对数组该索引位置的节点对象f进行加锁，如果是链表，锁的是头结点，如果是红黑树，锁的是整个红黑树对象TreeBin
            synchronized (f) {
            	// 双重检查，防止在加锁的过程中，该位置元素发生变化，如扩容、树化、移除等操作都会引起节点元素发生变化
                if (tabAt(tab, i) == f) {
                	// 在默认值中，可知TreeBin节点的hash值为-2且普通Node节点的hash值一定为正数
                    if (fh >= 0) {
                    	// 遍历链表，每次遍历binCount会加一
                        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;
                            }
                        }
                    }
                    // 这里表示f是一颗红黑树，在红黑树上面添加/替换一个元素
                    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;
                        }
                    }
                }
            }
            // 这里synchronized已经结束释放锁
            // 判断是否需要进行树化
            if (binCount != 0) {
                if (binCount >= TREEIFY_THRESHOLD)
                	// 树化，这里还会判断一下整体容量是否大于64.如果小于64进行扩容不树化，这里会再次加锁
                    treeifyBin(tab, i);
                if (oldVal != null)
                    return oldVal;
                break;
            }
        }
    }
    // 维护数组集合长度，及进行扩容操作
    addCount(1L, binCount);
    return null;
}

总结一下put流程：

  1. 首先判断不允许null值和null键
  2. 计算hash值，这个hash值一定是正数
  3. 对底层数组自旋，第一次需要进行底层数组的初始化
  4. 获取数组对应下标的元素f，如果为空，使用CAS放置一个节点进去，放置成功退出循环
  5. 如果f不为空，判断此节点的hash值是否为-1，如果为-1表示该数组正在进行扩容，先去协助扩容
  6. 自旋时以上条件都不满足，则对f节点进行加锁，f有可能是链表的头结点，也有可能是红黑树节点TreeBin
  7. 判断如果是链表的头节点，则对链表进行添加/修改操作，binCount记录链表元素的个数，判断是否需要树化（树化需单独再加锁）
  8. 判断如果f是一颗红黑树，则对红黑树进行添加/修改操作
  9. 维护集合长度，以及进行扩容操作

五：维护集合长度

ConcurrentHashMap在JDK1.8版本中对集合长度的维护是使用了一个基础变量baseCount加一个CounterCell计数器数组，CounterCell中有一个属性value
在这里插入图片描述
sumCount方法
首先取出baseCount，如果存在CounterCell数组，再遍历每一个CounterCell对象，对其value相加。

final long sumCount() {
    CounterCell[] as = counterCells; CounterCell a;
    long sum = baseCount;
    if (as != null) {
        for (int i = 0; i < as.length; ++i) {
            if ((a = as[i]) != null)
                sum += a.value;
        }
    }
    return sum;
}

addCount方法

private final void addCount(long x, int check) { 
    CounterCell[] as; long b, s;
    if ((as = counterCells) != null ||    // CounterCell数组不为空，优先利用数组中的CounterCell记录
    		// 如果CounterCell数组为空，再使用CAS对baseCount进行加操作
        !U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) { 
        // 如果CounterCell数组不为空，或者CounterCell数组为空且使用CAS对baseCount进行加操作失败，进入这里
        CounterCell a; long v; int m;
        // 标记是否没有多线程竞争 这里设置成无竞争
        boolean uncontended = true;
        if (as == null || (m = as.length - 1) < 0 ||	// 如果CounterCell数组为空		
            (a = as[ThreadLocalRandom.getProbe() & m]) == null || // 或者随机计算一个CounterCell数组位置对应对象为空
            !(uncontended =				// 或者对该CounterCell的value值使用CAS相加时失败  uncontended=false 表示有竞争
              U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))) {
              // 这里任何一个条件成立，都会执行fullAddCount
            fullAddCount(x, uncontended);
            // 
            return;
        }
        // 使用CAS修改CELLVALUE成功，则会到这里
        // check为binCount binCount始终大于等于0 
        // binCount等于0 表示在put值时Node数组对应的元素为空
        // binCount等于1 表示在put值时，是链表且链表只有一个key相同的元素，替换
        // 直接return，不需要再去检查是否需要扩容
        if (check <= 1)
            return;
        // 计算出此时map的大小
        s = sumCount();
    }
    // 判断是否需要扩容，
    if (check >= 0) {
        Node<K,V>[] tab, nt; int n, sc;
        // 如果元素个数大于等于扩容阈值或者-1
        while (s >= (long)(sc = sizeCtl) && (tab = table) != null &&
               (n = tab.length) < MAXIMUM_CAPACITY) {
             // 获取一个扩容的标记
            int rs = resizeStamp(n);
            // 如果sc小于0，表示其他线程在扩容
            if (sc < 0) {
                if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
                    sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
                    transferIndex <= 0)
                    break;
                // CAS对sczeCtl加1，表示有一个新的线程进入到扩容流程中
                if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
                	// 协助扩容
                    transfer(tab, nt);
            } 
            // 到达扩容阈值，去扩容，把sc改成一个负数（32位的最高位为1）
            // 这里会将sizeCtl设置成 resizeStamp(n) << RESIZE_STAMP_SHIFT) + 2，表示只有1个线程进行扩容操作
            else if (U.compareAndSwapInt(this, SIZECTL, sc,
                                         (rs << RESIZE_STAMP_SHIFT) + 2))
                // 扩容
                transfer(tab, null);
            s = sumCount();
        }
    }
}

fullAddCount方法

private final void fullAddCount(long x, boolean wasUncontended) {
    int h;
    // 获取当前线程的hash值（随机生成）
    if ((h = ThreadLocalRandom.getProbe()) == 0) {
        ThreadLocalRandom.localInit();      // force initialization
        h = ThreadLocalRandom.getProbe();
        wasUncontended = true;
    }
    // 冲突标志位，如果最后一个插槽不是null，那么为true
    boolean collide = false;                // True if last slot nonempty
    for (;;) { // for循环自旋
        CounterCell[] as; CounterCell a; int n; long v;
        // 如果CounterCell数组不为空
        if ((as = counterCells) != null && (n = as.length) > 0) {
        	// 如果计算出数组对应位置的CounterCell为空
            if ((a = as[(n - 1) & h]) == null) {
                if (cellsBusy == 0) {            // Try to attach new Cell
                	// 创建一个CounterCell对象
                    CounterCell r = new CounterCell(x); // Optimistic create
                    // 将CounterCell对象放置在数组对应的位置上，且要修改数组为忙碌状态1
                    if (cellsBusy == 0 &&
                        U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
                        boolean created = false;
                        try {               // Recheck under lock
                            CounterCell[] rs; int m, j;
                            if ((rs = counterCells) != null &&
                                (m = rs.length) > 0 &&
                                rs[j = (m - 1) & h] == null) {
                                // 再次判断桶位为空，将CounterCell对象放置在数组中
                                rs[j] = r;
                                created = true; // 表示放入成功
                            }
                        } finally {
                        	// 数组不忙了
                            cellsBusy = 0;
                        }
                        if (created)
                    		// 放入成功则退出循环
                            break;
                        // 如果该位置被别的线程放置了一个计数器，则继续循环
                        continue;           // Slot is now non-empty
                    }
                }
                collide = false;
            }
            // 当wasUncontended为flase时，进入，并赋值true，下次for循环则不会进入
            // 由于没有break，会重新计算hash值，下次循环时去判断其他的位置
            else if (!wasUncontended)       // CAS already known to fail
                wasUncontended = true;      // Continue after rehash
            else if (U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))
            	// 对CounterCell对象进行CAS加操作，加成功则跳出循环，不成功则重新计算hash值继续循环
                break;
            else if (counterCells != as || n >= NCPU)
            	// 这里相当于一个开关，当CounterCell数组有变动（扩容？）时，或者CounterCell数组的长度大于等于CPU的核数时，
            	// 将collide置为false，则让重新hash后下次进入
                collide = false;            // At max size or stale
            else if (!collide)
            	// 进入到这里，置为true，则下次循环才有可能进行扩容
                collide = true;
            else if (cellsBusy == 0 &&
                     U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
                     // 判断到达这里，会对CounterCell数组进行扩容2倍，并将原数组数据迁移到新数组中
                try {
                    if (counterCells == as) {// Expand table unless stale
                        CounterCell[] rs = new CounterCell[n << 1];
                        for (int i = 0; i < n; ++i)
                            rs[i] = as[i];
                        counterCells = rs;
                    }
                } finally {
                    cellsBusy = 0;
                }
                collide = false;
                continue;                   // Retry with expanded table
            }
            // if判断以后如果没有break，则会到达这里，重新进行hash
            h = ThreadLocalRandom.advanceProbe(h);
        }
        // 如果CounterCell数组为空，并且没有线程在创建数组，修改标记，并创建数组
        else if (cellsBusy == 0 && counterCells == as &&
                 U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
            boolean init = false;
            try {                           // Initialize table
                if (counterCells == as) {
                	// 创建一个长度为2的计数器数组
                    CounterCell[] rs = new CounterCell[2]; 
                    // 创建一个新的CounterCell对象
                    rs[h & 1] = new CounterCell(x);
                    counterCells = rs;
                    init = true;
                }
            } finally {
            	// 将标记修改回来
                cellsBusy = 0;
            }
            if (init)
            	// 创建数组并初始化成功，break，退出循环
                break;
        } 
        // CounterCell数组为空，并且此时有其他线程在创建这个数组，那么该线程就去尝试对baseCount相加，如果加成功则退出循环，加不成功则继续自旋
        else if (U.compareAndSwapLong(this, BASECOUNT, v = baseCount, v + x))
            break;                          // Fall back on using base
    }
}

集合大小的维护总结：

  1. 首先判断CounterCell数组是否为空，如果为空的话，则使用CAS修改baseCount的值
  2. 如果CounterCell数组不为空，或者直接CAS修改baseCount值失败，则继续3
  3. 判断数组是否为空，或计算出（取随机值）对应位置是否为空，或CAS修改数组对应位置对象value属性失败，满足任意条件就调用fullAddCount方法，去计数，并返回
  4. fullAddCount方法自旋计数，使用CAS对CounterCell数组或baseCount进行计数，多线程下会有各种情况，具体请看代码分析
  5. 如果3中的所有条件都不成立，即最终使用CAS修改CounterCell对象的value属性成功，判断check是否小于等于1，是否需要继续执行扩容逻辑
  6. 如果sizeCtl小于0，去协助扩容，不小于0，则使用CAS将其变成小于0的数，并进行扩容

六：helpTransfer()协助扩容

final Node<K,V>[] helpTransfer(Node<K,V>[] tab, Node<K,V> f) {
        Node<K,V>[] nextTab; int sc;
        // 原数组不为空，f节点已经被其他线程转移过（fwd节点）,新数组临时变量不为空，去协助扩容
        if (tab != null && (f instanceof ForwardingNode) &&
            (nextTab = ((ForwardingNode<K,V>)f).nextTable) != null) {
            int rs = (tab.length);
            while (nextTab == nextTable && table == tab &&
                   (sc = sizeCtl) < 0) {
                if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
                    sc == rs + MAX_RESIZERS || transferIndex <= 0)
                    // 不需要扩容
                    break;
                if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1)) {
                	// 进入扩容，会将sizeCtl加1
                    transfer(tab, nextTab);
                    break;
                }
            }
            return nextTab;
        }
        return table;
    }

七：transfer()扩容

1.8中可以多线程协助扩容，在扩容时会将原数组划分成若干个任务块，每一个线程在扩容时领取一个任务块，最小为16
单线程或多线程转移时都计算i与bound，i表示当前线程要转移的最开始的hash表下标，bound表示此次任务最后要转移的hash表下标，从后往前转移。
每转移完一个hash表的桶位，将其设置为fwd节点，并继续向前推进（–i）与bound进行比较，直至转移完bound位置，此次任务结束。
当最后一个线程转移完0位置元素，标记finishing为true，表示完成
在这里插入图片描述

private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
        int n = tab.length, stride;
        // 获取步长，最短为16，即每个线程每一次领取的任务至少要转移哈希表中16个节点的数据
        // 这里先判断CPU核数是否大于1 如果不大于1则没有必要多线程扩容
        if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
            stride = MIN_TRANSFER_STRIDE; // subdivide range
        // 为null表示要生成一个原数组大小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;
            // n为旧tab的length，赋值给transferIndex 
            transferIndex = n;
        }
        int nextn = nextTab.length;
        // 新建一个ForwardingNode节点，将原hash表中元素转移以后，会在原位置放置一个fwd节点，表示已经转移
        ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);
        boolean advance = true;
        boolean finishing = false; // to ensure sweep before committing nextTab
        for (int i = 0, bound = 0;;) {
            Node<K,V> f; int fh;
            // 向前推进，i减一
            while (advance) {
                int nextIndex, nextBound;
                // i会先减一
                // 当前任务块已经转移完（i<bound）或者最后一个线程转移结束，advance改为false，不再计算i和bound
                if (--i >= bound || finishing) 
                    advance = false;
                else if ((nextIndex = transferIndex) <= 0) {
                	// 已经转移到0位置
                    i = -1;
                    advance = false;
                }
                // 计算需要转移的任务块的i和bound
                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;
                    sizeCtl = (n << 1) - (n >>> 1);
                    return;
                }
                if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
                	// 如果sc != resizeStamp(n) << RESIZE_STAMP_SHIFT + 2
                	// 则表示当前线程不是最后一个扩容的线程，直接退出
                    if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)
                        return;
                    // 当前是最后一个扩容的线程，标记finishing、advance为true
                    // 继续while循环，进入收尾工作
                    finishing = advance = true;
                    i = n; // recheck before commit
                }
            }
            else if ((f = tabAt(tab, i)) == null)
            	// 如果原数组i位置为空，直接使用cas放置一个fwd节点
            	// 放置成功，继续向前推进，i会减一
            	// 放置失败
                advance = casTabAt(tab, i, null, fwd);
            else if ((fh = f.hash) == MOVED)
            	// 当前节点已经转移过了，继续向前推进
                advance = true; // already processed
            else {
            	// 这里真正去转移数据，判断是链表还是红黑树
                synchronized (f) {
                    if (tabAt(tab, i) == f) { // 判断tab的i的位置是否还是f，双重校验
                        Node<K,V> ln, hn; // 定义两个桶 低位和高位
                        // 普通节点的hash值大于0，红黑树节点hash值为-2
                        if (fh >= 0) {
                            int runBit = fh & n;
                            Node<K,V> lastRun = f;
                            // 先遍历一遍这个桶，lastRun机制，并且计算runBit
                            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为0，最后匹配的链表放在低位
                            if (runBit == 0) {
                                ln = lastRun;
                                hn = null;
                            } // 如果为1 将lastRun链表放高位
                            else {
                                hn = lastRun;
                                ln = null;
                            }
                            for (Node<K,V> p = f; p != lastRun; p = p.next) {
                                int ph = p.hash; K pk = p.key; V pv = p.val;
                                if ((ph & n) == 0)
                                    ln = new Node<K,V>(ph, pk, pv, ln);
                                else
                                    hn = new Node<K,V>(ph, pk, pv, hn);
                            }
                            setTabAt(nextTab, i, ln); // 新数组对应低位
                            setTabAt(nextTab, i + n, hn); // 新数组对应高位
                            // 原数组放一个fwd节点，表示原数组位置已经转移结束
                            setTabAt(tab, i, fwd);
                            // 继续往前推进
                            advance = true;
                        }
                        // 如果是红黑树
                        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;
                                }
                            }
                            // 如果红黑树的元素个数小于等于6，转成链表，若大于6则生成一颗新的红黑树
                            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;
                        }
                    }
                }
            }
        }
    }

结语：还在学习过程中，做一个学习记录，如有不对的地方，欢迎批评指正。

小姬同学在Coding
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ConcurrentHashMap 源码分析（JDK1.8）
淦淦淦！
02-14 337
ConcurrentHashMap（JDK1.8）实现线程安全的思想也已经完全变了，它摒弃了Segment（锁段）的概念，而是启用了一种全新的方式实现,利用CAS算法。它沿用了与它同时期的HashMap版本的思想，底层依然由“数组”+链表+红黑树的方式思想。 前言 在学习 ConcurrentHashMap 源码之前你需要知道以下知识： HashMap 源码分析（JDK1.8） （由于 Conc...
Map源码解析之ConcurrentHashMap(JDK1.8)(一)
翻身已碰头的博客
03-06 721
Map源码解析之HashMap Map源码解析之HashMap红黑树 Map源码解析之HashMap补充：集合、迭代器、compute、merge、replace Map源码解析之LinkedHashMap Map源码解析之TreeMap Map源码解析之HashTable 一、简述 HashMap和LinkedHashMap都不是线程安全的，而线程安全的HashTable和Collections...
【多线程】ConcurrentHashMap1.8源码保姆级解析
aqin1012的博客
06-26 1419
基于一个while循环，先去判断数组初始化了没有，如果没有，会再次比较sizeCtl的情况，如果正在初始化，则会通过Thread.yield()让出CPU资源，如果没有初始化，则会通过CAS的方式修改sizeCtl的值为-1，修改过后还会再次判断数组是否被初始化了（DCL，以免在当前线程修改sizeCtl的值的时候，已经有别的线程对当前数组完成了初始化），如果当前数组仍然没有被初始化，才会真正开始初始化。>0：代表当前数组已经初始化完成，此时sizeCtl的值代表当前数组的扩容阈值，或者数组的初始化大小。
ConcurrentHashMap -1.8 源码解析
qq_50596778的博客
11-08 3639
ConcurrentHashMap -1.8 源码解析 加锁机制 在JDK1.7之前，ConcurrentHashMap是通过分段锁机制来实现的，所以其最大并发度受Segment的个数限制。因此，在JDK1.8中，ConcurrentHashMap的实现原理摒弃了这种设计，而是选择了与HashMap类似的数组+链表+红黑树的方式实现，而加锁则采用CAS和synchronized实现。 存储结构 Java8 的 ConcurrentHashMap 相对于 Java7 来说变化比较大，从1.7的 Segment
ConcurrentHashMap源码分析(1.8)
FYHannnnnn的博客
01-18 1733
0、说明  1、ConcurrentHashMap跟HashMap，HashTable的对比 2、ConcurrentHashMap原理概览 3、ConcurrentHashMap几个重要概念 4、ConcurrentHashMap几个重要方法 5、ConcurrentHashMap的初始化 6、ConcurrentHashMap的put操作详解 7、ConcurrentHashMap的扩容详解 8、ConcurrentHashMap的get操作详解 9、Con...
java源码分析之-ConcurrentHashMap1.8
hao495430759的专栏
06-27 3544
超详细ConcurrentHashMap 1.8源码剖析，各种细节解答
深入理解ConcurrentHashMap1.8源码
XHHP
12-31 976
之前介绍了ConcurrentHashMap1.7，采用的是数组+分段锁的方式来实现的。虽然说采用分段锁的方式能够在一定程度上提高并发的效率，但是锁的粒度是Segment级别的，其实还是挺大的。于是，ConcurrentHashMap1.8继续在1.7版本上进行改进，将锁的粒度进一步减小，变成Node级别，又提升了并发的效率。
Java并发包源码分析(JDK1.8)
06-13
Java并发包源码分析(JDK1.8)：囊括了java.util.concurrent包中大部分类的源码分析，其中涉及automic包，locks包(AbstractQueuedSynchronizer、ReentrantLock、ReentrantReadWriteLock、LockSupport等)，queue...
JDK1.8:JDK1.8源码解析-源码解析
03-24
JDK1.8的源码分析可以帮助开发者深入理解这些新特性的实现原理，优化代码性能，并从中学习到高级并发编程和设计模式。通过阅读源码，我们可以学习到如何在多线程环境下设计高效、线程安全的数据结构，以及如何利用新...
jdk1.8-source:JDK1.8源码分析包
03-23
JDK1.8源码分析 相关的原始码分析结果会以注解的形式体现到原始码中 已完成部分： ReentrantLock CountDownLatch Semaphore HashMap TreeMap LinkedHashMap ConcurrentHashMap 执行器 ...
JDK1.8 ConcurrentHashMap的一点理解
01-07
只是都是相通的，当我们了解了ConcurrentHashMap的实现原理以及各个方法的实现机制，我们对于其他的hash类型实现也能快速的理解，今天我们就来通过源码来一点一点的分析下ConcurrentHashMap的实现。 首先我们来看...
JDK1.8中ConcurrentHashMap源码解析
小志的博客
11-16 1369
目录一、ConcurrentHashMap使用场景二、put方法的整体流程三、第一种情况（初始化table数组）1、initTable源码如下：2、sizeCtl3、流程解释四、第二种情况（寻址后的位置没有被占用）1、源码如下 一、ConcurrentHashMap使用场景 我们平时最常用的HashMap其实不是线程安全的，而当我们有多线程使用场景的时候，即想线程安全，又想拥有Map的能力，我们可以选择HashTable，因为它是针对我们常用的方法上面加上了synchronize锁，但是在高并发的场景下
JAVA并发编程：深入解析JDK1.8中HashMap、并发容器ConcurrentHashMap原理及其源码分析
菜鸟技术栈的专栏
08-12 1006
一、HashMap详解 1、基本介绍 1.1 概述
ConcurrentHashMap 1.8 源码剖析(超详细)，不懂Java的女朋友们都听懂了
H.CF的博客
02-15 629
本文主要讨论 1.8 的源码实现，1.7的简单掠过 ConcurrentHashMap 1.7 底层实现是数组 + 链表 + segment 分段加锁 ConcurrentHashMap 在1.7中存在的问题 Hash 冲突严重导致节点上的链表过长，到时候遍历链表的效率太低 ConcurrentHashMap 1.8 底层实现是数组 + 链表或者红黑树 + CAS + synchroni...
ConcurrentHashMap 1.8源码详解
weixin_44577346的博客
11-15 601
ConcurrentHashMap 1.8源码详解一、jdk1.8容器初始化 一、jdk1.8容器初始化 //没有进行任何操作，在添加数据时才会创建数组 public ConcurrentHashMap() { } //initialCapacity：指定数组初始长度(创建出的数组长度不是这个值) public ConcurrentHashMap(int initialCapacity) { if (initialCapacity < 0) thro
ConcurrentHashMap1.8 源码分析
[爪洼ing]的博客
10-24 2741
一、容器初始化 在jdk8的ConcurrentHashMap中一共有5个构造方法，这四个构造方法中都没有对内部的数组做初始化， 只是对一些变量的初始值做了处理 jdk8的ConcurrentHashMap的数组初始化是在第一次添加元素时完成 //没有维护任何变量的操作，如果调用该方法，数组长度默认是16 public ConcurrentHashMap() { } //传递进来一个初始容量，ConcurrentHashMap会基于这个值计算一个比这个值大的2的幂次方数作为初始容量 public Conc
12. Hibernate 模板设计模式
最新发布
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1137
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
concurrenthashmap 插入过程jdk1.8
04-02
ConcurrentHashMap的插入过程包括以下步骤： 1. 确定插入的hash值和插入的键值对对象。 2. 根据hash值，确定需要插入的segment段。 3. 通过获取segment的锁，确保线程安全，进行插入操作。 4. 如果当前segment中已经存在相同的键值对，则直接替换原有的值。 5. 如果当前segment中不存在相同的键值对，则将键值对插入到segment中。 6. 如果segment中的元素个数超过了阈值，则通过rehash操作，将该segment中的元素重新分配到其他segment中。 7. 如果整个ConcurrentHashMap中的元素个数超过了阈值，则通过resize操作，将所有元素重新分配到更多的segment中。 8. 最后释放segment的锁，完成插入操作。 需要注意的是，ConcurrentHashMap的插入操作是线程安全的，可以同时被多个线程进行，但是在进行resize操作时会对所有的线程产生影响，因此可能会导致一定的性能损失。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值