JDK1.8 ConcurrentHashMap源码细致分解01

最新推荐文章于 2022-09-16 16:45:05 发布
最新推荐文章于 2022-09-16 16:45:05 发布
阅读量609 收藏
点赞数 1
分类专栏： java并发编程 hashmap java集合 文章标签： java 并发hashMap
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46410481/article/details/122558088
版权

文章参考：小刘讲源码

ConcurrentHashMap 源码解析_01 成员属性、内部类、构造方法解析

1、简介

先简单介绍一下 ConcurrentHashMap 的整体流程：

整体流程跟 HashMap 比较类似，大致是以下几步：

  1. 如果桶数组未初始化，则初始化；
  2. 如果待插入的元素所在的桶为空，则尝试把此元素直接插入都桶中的第一个位置；
  3. 如果正在扩容，则当前线程一起加入到扩容的过程中；
  4. 如果待插入的元素所在的桶不为空且不存在迁移的元素，则锁住这个桶（分段锁）
  5. 如果当前桶中元素以链表方式存储，则在链表中寻找该元素或者插入元素；
  6. 如果当前桶中元素以红黑树方式存储，则在红黑树中寻找该元素或者插入元素；
  7. 如果元素存在，则返回旧值
  8. 如果元素不存在，整个 Map 的元素加 1，并检查是否需要扩容；

添加元素操作中使用的锁主要有（自旋锁 + CAS + synchronized + 分段锁）。

为什么使用 synchronized 而不是 ReentrantLock？

因为 synchronized 已经得到了极大的优化，在特定情况下并不比 ReentrantLock 差。

2、JDK1.8 ConcurrentHashMap 结构图

7JmSCq.png

3、成员属性

/**
 * 散列表数组最大限制
 */
private static final int MAXIMUM_CAPACITY = 1 << 30;

/**
 * 散列表默认值
 */
private static final int DEFAULT_CAPACITY = 16;

/**
 * 支持的数组最大长度，不少MAX_INTEGER_VALUE
 */
static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

/**
 * 并发级别：JDK1.7遗留下来的，JDK1.8只有在初始化的时候用了一用，并不代表并发级别
 */
private static final int DEFAULT_CONCURRENCY_LEVEL = 16;

/**
 * 负载因子，JDK1.8中，ConcurrentHashMap是固定值
 */
private static final float LOAD_FACTOR = 0.75f;

/**
 * 树化阙值，指定桶位  链表长度达到8的话，有可能发生树化操作
 */
static final int TREEIFY_THRESHOLD = 8;

/**
 * 红黑树转化为链表的阙值
 */
static final int UNTREEIFY_THRESHOLD = 6;

/**
 * 联合TREEIFY_THRESHOLD控制桶位是否树化条件，只有当table数组长度达到64且某个桶位中的链表长度达到8才会真正树化
 */
static final int MIN_TREEIFY_CAPACITY = 64;

/**
 * 线程迁移数据最小步长，控制线程迁移任务最小区间的一个值
 */
private static final int MIN_TRANSFER_STRIDE = 16;

/**
 * 扩容相关，计算扩容时生成的一个标识戳
 */
private static int RESIZE_STAMP_BITS = 16;

/**
 * 65535，表示并发扩容最多线程数
 */
private static final int MAX_RESIZERS = (1 << (32 - RESIZE_STAMP_BITS)) - 1;

/**
 * 扩容相关
 */
private static final int RESIZE_STAMP_SHIFT = 32 - RESIZE_STAMP_BITS;

/*
 * Encodings for Node hash fields. See above for explanation.
 */
// 当node节点的hash值为-1的时候，表示当前节点是FWD节点
static final int MOVED     = -1; // hash for forwarding nodes
// 当node节点的hash值是-2的时候，表示当前节点已经树化了且当前节点为TreeBin对象，TreeBin对象代理操作红黑树
static final int TREEBIN   = -2; // hash for roots of trees
static final int RESERVED  = -3; // hash for transient reservations
// 0x7fffffff => 0111 1111 1111 1111 1111 1111 1111 1111 可以将一个负数通过位与运算后得到正数，但是不少取绝对值
static final int HASH_BITS = 0x7fffffff; // usable bits of normal node hash

// 当前系统的CPU数量
static final int NCPU = Runtime.getRuntime().availableProcessors();

// 散列表对象，长度一定是2的次方数
transient volatile Node<K,V>[] table;

// 扩容过程中会将扩容中的新table赋值给nextTable，保持引用，扩容结束之后，这里会被设置为null
private transient volatile Node<K,V>[] nextTable;

// LongAdder中的baseCount，未发生竞争的时候或者当前LongAdder处于加锁状态中，增量累加到baseCount中
private transient volatile long baseCount;

/**
 * sizeCtl < 0
 * 1.-1的时候表示当前的table正在初始化（有线程正在创建table数组）当前线程需要自旋等待
 * 2.表示当前map正在进行扩容，高16位表示：扩容的标识戳 低16位表示：(1 + nThread)表示当前参与并发扩容的线程数量
 *
 * sizeCtl == 0 表示创建table数组的时候，使用DEFAULT_CAPACITY 为大小
 *
 * sizeCtl > 0
 * 1. 如果table未初始化，表示初始化大小
 * 2. 如果table已经初始化，表示下次扩容时的触发条件（阙值）
 */
private transient volatile int sizeCtl;

// 扩容过程中，记录当前进度，所有线程都需要从transferIndex中分配区间任务，去执行自己的任务
private transient volatile int transferIndex;

// LongAdder 中的cellsBusy 0表示当前LongAdder对象无锁状态，1表示处于加锁状态
private transient volatile int cellsBusy;

// LongAdder 中的cells数组，当baseCount发生竞争后，会创建cells数组
// 多线程情况下，线程会通过计算hash值取到自己的cell位置，将增量累加到cell中
// 总个数 = sum(cells) + baseCount
private transient volatile CounterCell[] counterCells;

4、静态属性

// Unsafe mechanics
private static final sun.misc.Unsafe U;
// 表示sizeCtl属性在ConcurrentHashMap中的内存偏移地址
private static final long SIZECTL;
// 表示transferIndex属性在ConcurrentHashMap中的内存偏移地址
private static final long TRANSFERINDEX;
// 表示baseCount属性在ConcurrentHashMap中的内存偏移地址
private static final long BASECOUNT;
// 表示cellsbusy属性在ConcurrentHashMap中的内存偏移地址
private static final long CELLSBUSY;
// 表示cellsvalue属性在CounterCell中的内存偏移地址
private static final long CELLVALUE;
// 表示数组第一个元素的偏移地址
private static final long ABASE;
// 该属性用于数组寻址，轻继续往下阅读即可了解
private static final int ASHIFT;

5、静态代码块

static {
    try {
        U = sun.misc.Unsafe.getUnsafe();
        Class<?> k = ConcurrentHashMap.class;
        SIZECTL = U.objectFieldOffset
            (k.getDeclaredField("sizeCtl"));
        TRANSFERINDEX = U.objectFieldOffset
            (k.getDeclaredField("transferIndex"));
        BASECOUNT = U.objectFieldOffset
            (k.getDeclaredField("baseCount"));
        CELLSBUSY = U.objectFieldOffset
            (k.getDeclaredField("cellsBusy"));
        Class<?> ck = CounterCell.class;
        CELLVALUE = U.objectFieldOffset
            (ck.getDeclaredField("value"));
        Class<?> ak = Node[].class;
        // 拿到数组第一个元素的偏移地址
        ABASE = U.arrayBaseOffset(ak);
        // 表示数组中每一个单元所占用的空间大小，即scale表示Node[]数组中每一个单元所占用的空间
        int scale = U.arrayIndexScale(ak);
        // (scale & (scale - 1)) != 0：判断scale的数值是否是2的次幂数
        // java语言规范中，要求数组中计算出的scale必须为2的次幂数
        // 1 0000 % 0 1111 = 0
        if ((scale & (scale - 1)) != 0)
            throw new Error("data type scale not a power of two");
        // numberOfLeadingZeros(scale) 根据scale，返回当前数值转换为二进制后，从高位到地位开始统计，统计有多少个0连续在一块：eg, 8转换二进制=>1000 则 numberOfLeadingZeros(8)的结果就是28，为什么呢？因为Integer是32位，1000占4位，那么前面就有32-4个0，即连续最长的0的个数为28个
        // 4转换二进制=>100 则 numberOfLeadingZeros(8)的结果就是29
        // ASHIFT = 31 - Integer.numberOfLeadingZeros(4) = 2 那么ASHIFT的作用是什么呢？其实它有数组寻址的一个作用：
        // 拿到下标为5的Node[]数组元素的偏移地址(存储地址)：假设此时 根据scale计算得到的ASHIFT = 2
        // ABASE + (5 << ASHIFT) == ABASE + (5 << 2) == ABASE + 5 * scale，就得到了下标为5的数组元素的偏移地址
        ASHIFT = 31 - Integer.numberOfLeadingZeros(scale);
    } catch (Exception e) {
        throw new Error(e);
    }
}

6、内部类

6.1、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;

    Node(int hash, K key, V val, Node<K,V> next) {
        this.hash = hash;
        this.key = key;
        this.val = val;
        this.next = next;
    }

    public final K getKey()       { return key; }
    public final V getValue()     { return val; }
    public final int hashCode()   { return key.hashCode() ^ val.hashCode(); }
    public final String toString(){ return key + "=" + val; }
    public final V setValue(V value) {
        throw new UnsupportedOperationException();
    }

    // 这里equals是以Entry节点来进行比较访问的
    public final boolean equals(Object o) {
        Object k, v, u; Map.Entry<?,?> e;
        return ((o instanceof Map.Entry) &&
                (k = (e = (Map.Entry<?,?>)o).getKey()) != null &&
                (v = e.getValue()) != null &&
                (k == key || k.equals(key)) &&
                (v == (u = val) || v.equals(u)));
    }

    /**
     * Virtualized support for map.get(); overridden in subclasses.
     */
    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;
    }
}

6.2、ForwardingNode 节点

这个内部类在之后分析扩容的时候会再仔细进行探究，这里先熟悉一下：

// 如果是一个写的线程(eg：并发扩容线程)，则需要为创建新表贡献一份力
// 如果是一个读的线程，则调用该内部类的find(int h, Object k)方法
static final class ForwardingNode<K,V> extends Node<K,V> {
    // nextTable表示新散列表的引用
    final Node<K,V>[] nextTable;
    ForwardingNode(Node<K,V>[] tab) {
        super(MOVED, null, null, null);
        this.nextTable = tab;
    }
    // 到新表上去读数据
    Node<K,V> find(int h, Object k) {
        // loop to avoid arbitrarily deep recursion on forwarding nodes
        outer: for (Node<K,V>[] tab = nextTable;;) {
            Node<K,V> e; int n;
            if (k == null || tab == null || (n = tab.length) == 0 ||
                (e = tabAt(tab, (n - 1) & h)) == null)
                return null;
            for (;;) {
                int eh; K ek;
                if ((eh = e.hash) == h &&
                    ((ek = e.key) == k || (ek != null && k.equals(ek))))
                    return e;
                if (eh < 0) {
                    if (e instanceof ForwardingNode) {
                        tab = ((ForwardingNode<K,V>)e).nextTable;
                        continue outer;
                    }
                    else
                        return e.find(h, k);
                }
                if ((e = e.next) == null)
                    return null;
            }
        }
    }
}

6.3、TreeNode 节点

TreeBin 中会用到该节点，之后会进行细说：

static final class TreeNode<K,V> extends Node<K,V> {
    // 父节点
    TreeNode<K,V> parent;  // red-black tree links
    // 左子节点
    TreeNode<K,V> left;
    // 右节点
    TreeNode<K,V> right;
    // 前驱节点
    TreeNode<K,V> prev;    // needed to unlink next upon deletion
    // 节点有红、黑两种颜色~
    boolean red;
    TreeNode(int hash, K key, V val, Node<K,V> next,
             TreeNode<K,V> parent) {
        super(hash, key, val, next);
        this.parent = parent;
    }
    Node<K,V> find(int h, Object k) {
        return findTreeNode(h, k, null);
    }
    /**
     * Returns the TreeNode (or null if not found) for the given key
     * starting at given root.
     */
    final TreeNode<K,V> findTreeNode(int h, Object k, Class<?> kc) {
        if (k != null) {
            TreeNode<K,V> p = this;
            do  {
                int ph, dir; K pk; TreeNode<K,V> q;
                TreeNode<K,V> pl = p.left, pr = p.right;
                if ((ph = p.hash) > h)
                    p = pl;
                else if (ph < h)
                    p = pr;
                else if ((pk = p.key) == k || (pk != null && k.equals(pk)))
                    return p;
                else if (pl == null)
                    p = pr;
                else if (pr == null)
                    p = pl;
                else if ((kc != null ||
                          (kc = comparableClassFor(k)) != null) &&
                         (dir = compareComparables(kc, k, pk)) != 0)
                    p = (dir < 0) ? pl : pr;
                else if ((q = pr.findTreeNode(h, k, kc)) != null)
                    return q;
                else
                    p = pl;
            } while (p != null);
        }
        return null;
    }
}

7、构造方法

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

public ConcurrentHashMap(Map<? extends K, ? extends V> m) {
    this.sizeCtl = DEFAULT_CAPACITY;
    putAll(m);
}

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

构造方法与 HashMap 对比可以发现，没有了 HashMap 中的 thresold 和 loadFactor，而是改用了 sizaCtl 来控制，而且只存储了容量里面，那么它是怎么用的呢？官方给出的解释如下：

  • -1，表示有线程正在进行初始化操作。
  • -(1 + nThreads)，表示有 n 个线程正在一起扩容。
  • 0，默认值，后续再真正初始化的时候使用默认容量。
  • > 0，初始化或者扩容完成后下一次的扩容门槛。

8、内部小方法分析

下面在正式分析并发 HashMap 成员方法之前，先分析一些内部类中的子方法函数：

首先看一下 ConcurrentHashMap 内部类 Node 中的 hash 成员属性值的计算方法 spread(int h)：

static class Node<K,V> implements Map.Entry<K,V> {
    final int hash;// 该属性是通过spread(int h)方法计算得到~ h 代表key
    final K key;
    volatile V val;
    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;
    }
    ...
}

8.1、spread(int h) 方法

// 扰动函数
/**
 * 计算Node 节点hash 值的算法：参数为h的hash值
 * eg:
 * h二进制为：-->                  1100 0011 1010 0101 0001 1100 0001 1110
 * (h >>> 16) -->                0000 0000 0000 0000 1100 0011 1010 0101
 * (h ^ (h >>> 16)) -->          1100 0011 1010 0101 1101 1111 1011 1011
 * 注意：(h ^ (h >>> 16)) 目的是让h的高16位也参与进来寻址，使得到的哈希值更加的分散，减少哈希冲突的次数
 * --------------------------------------------------------------------------------------
 * HASH_BITS -->                 0111 1111 1111 1111 1111 1111 1111 1111
 * (h ^ (h >>> 16)) -->          1100 0011 1010 0101 1101 1111 1011 1011
 * (h ^ (h >>> 16)) & HASH_BITS  0100 0011 1010 0101 1101 1111 1011 1011
 * 注意，(h ^ (h >>> 16)) 得到的结果在 & HASH_BITS，目的是为了让得到的hash值结果始终是一个正数
 */
static final int spread(int h) {
    // 让原来的hash值异或^原来hash值的右移16位，再&上HASH_BITS(0x7fffffff:二进制位31个1)
    return (h ^ (h >>> 16)) & HASH_BITS;
}

下面介绍 tabAt(Node<K,V>[] tab, int i)方法：获取 tab[Node[]] 数组指定下标 i 的 Node 节点。

8.2、tabAt（Node<K,V>[] tab, int i） 方法

/**
 * 获取 tab(Node[]) 数组中指定下标位置 i 的Node元素
 * Node<K,V> tab:表示Node[]数组
 * int i：表示数组下标
 */
@SuppressWarnings("unchecked")
static final <K,V> Node<K,V> tabAt(Node<K,V>[] tab, int i) {
    // ((long)i << ASHIFT) + ABASE的作用：请看下面的分析
    return (Node<K,V>)U.getObjectVolatile(tab, ((long)i << ASHIFT) + ABASE);
}

再分析 ((long)i << ASHIFT) + ABASE 的时候，先复习一下上面所说的介绍的一些静态属性字段的含义：

// Node 数组的Class 对象
Class<?> ak = Node[].class;
// U.arrayBaseOffset(ak)：根据ak 获取NOde[] 数组第一个元素的偏移地址
ABASE = U.arrayBaseOffset(ak);
// 表示数组单元所占用空间大小，scale表示Node[]数组中每一个单元所占用的空间大小
int scale = U.arrayIndexScale(ak);
// 在java语言中scale必须是二的次方数，这里就是一个小算法判断scale是不是二的次方数
// 如果不是则报错
if ((scale & (scale - 1)) != 0)
    throw new Error("data type scale not a power of two");
// numberOfLeadingZeros(scale)：根据scale，返回的当前数值转化位二进制后，这里注意（scale的值一定是2的次幂数）,从那个高位到低位开始统计，统计有多少个0连续在一块
// eg:8 -> 1000 则numberOfLeadingZeros(8) 的值就是28，为什么呢？因为Integer是32位，1000占4位，那么前面就有32-4个0，即连续最长的0的个数为28个
// 4-> 100，则numberOfLeadingZeros(4)的值就是29
// ASHIFT = 31 - Integer.numberOfLeadingZeros(4) = 2，那么ASHIFT的作用是什么呢？其实它有一个数组寻址的一个作用：
// 拿到下标为5的Node[] 数组元素的偏移地址(存储地址)：假设此时根据scale计算得到的ASHIFT = 2
// ASHIFT主要是用于内存寻址的时使用，假如我们要寻找第6桶位的地址，ABSE + 5 * scale
// 转化为 ABASE + (5 << ASHIFT)
ASHIFT = 31 - Integer.numberOfLeadingZeros(scale);

由上面的几个属性字段的复习介绍，不难得出：

  • ((long)i << ASHIFT) + BASE 就是得到当前 Node[] 数组下标为 i 的节点对象的偏移地址。
  • 然后再通过 (Node<K,V>)U.getObjectVolatile(tab, ((long)i << ASHIFT) + ABASE) 方法，根据 Node[] 和 目标节点 Node 的偏移地址 两个参数，得到下标为 i 的 Node 节点对象。
  • 虽然这样很绕，不如直接使用乘法看起来简便，但是直接根据偏移地址去寻找数组元素效率较高。

8.3、casTabAt（Node<K,V>[] tab, int i） 方法

/**
 * 通过 CAS 的方式去向Node 数组指定位置i设置节点值，设置成功返回true，否则返回false
 * Node<K,V>[] tab：表示Node[] 数组
 * int i：表示数组下标
 * Node<K,V> c：期望节点值
 * Node<K,V> v：要设置的节点值
 */
static final <K,V> boolean casTabAt(Node<K,V>[] tab, int i,
                                    Node<K,V> c, Node<K,V> v) {
    // 调用Unsafe的比较并交换去设置Node[]数组指定位置的节点值，参数如下：
    // tab：Node[] 数组
    // ((long)i << ASHIFT) + ABASE：下标为i的数组桶的偏移地址
    // c：期望节点值
    // v：要设置的节点的新值
    return U.compareAndSwapObject(tab, ((long)i << ASHIFT) + ABASE, c, v);
}

8.4、setTabAt(Node<K,V>[] tab, int i, Node<K,V> v)方法

/**
 * 根据数组下标，设置 Node[] 数组指定下标位置的节点值：
 * Node<K,V>[] tab：表示 Node[] 数组
 * int i：表示数组下标
 * Node<K,V> v：要设置的节点值
 */
static final <K,V> void setTabAt(Node<K,V>[] tab, int i, Node<K,V> v) {
    // ((long)i << ASHIFT) + ABASE：下标为i数组桶的偏移地址
    U.putObjectVolatile(tab, ((long)i << ASHIFT) + ABASE, v);
}

8.5、resizeStamp(int n) 方法

// table数组扩容给的时候，计算出一个扩容标识戳，当需要并发扩容的时候，当前线程必须拿到扩容标识戳才能参与到扩容中去
static final int resizeStamp(int n) {
    // RESIZE_STAMP_BITS：固定值 16，与扩容相关，计算扩容的时候会根据该属性值生成一个扩容标识戳
    return Integer.numberOfLeadingZeros(n) | (1 << (RESIZE_STAMP_BITS - 1));
}

举例子分析一下：

  • 当我们需要 table 容量从 16 扩容到 32的时候，Integer.numberOfLeadingZeros(16) 会得到 27，怎么得来的呢？
    • numberOfLeadingZeros(n) 根据传入的 n，返回当前数值转换为二进制后，从高位到低位开始统计，统计有多少个0连续再一块：
      • eg：16 转换二进制 => 1 0000 则 numberOfLeadingZeros(16) 的结果就是 27，因为 Integer 是32位，1 0000 占5位，那么前面就有 32 - 5 个 0，即连续最长的 0 个数为 27 个。
  • 1 << (RESIZE_STAMP_BITS - 1) ：其中 RESIZE_STAMP_BITS 是一个固定值 16，与扩容相关，计算扩容的时候会根据该属性值生成一个扩容标识戳。、
  • 下面就来计算一下：
// 从 16 扩容到 32
16 -> 32
numberOfLeadingZeros(16) => 1 0000 => 27 => 0000 0000 0001 1011
// 用 B 表示：
(1 << (RESIZE_STAMP_BITS - 1)) => (1 << (16 - 1)) => 1000 0000 0000 0000 => 32768

// A | B
Integer.numberOfLeadingZeros(n) | (1 << (RESIZE_STAMP_BITS - 1)) 
-----------------------------------------------------------------
0000 0000 0001 1011   ---> A
1000 0000 0000 0000   ---> B
-------------------  ---> | 按位或 
1000 0000 0001 1011  ---> 计算得到扩容标识戳

8.6、tableSizeFor(int c) 方法

/**
 * 返回大于等于 c 的最小的2的次方数
 * eg: c = 28
 * n = c - 1 = 27 -> 0b11011
 * n |= n >>> 1
 * n => 11011 |= 01101 => 11111
 * n |= n >>> 2
 * n => 11111 |= 00111 => 11111
 * ...
 * => 1111 + 1 = 32
 */
private static final int tableSizeFor(int c) {
    int n = c - 1;
    n |= n >>> 1;
    n |= n >>> 2;
    n |= n >>> 4;
    n |= n >>> 8;
    n |= n >>> 16;
    return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}

8.7、构造方法

// 无参构造方法
public ConcurrentHashMap() {
}

// 指定初始化容量
public ConcurrentHashMap(int initialCapacity) {
    // 判断给定的数组初始长度是否小于0，小于0的话直接抛出异常
    if (initialCapacity < 0)
        throw new IllegalArgumentException();
    int cap = ((initialCapacity >= (MAXIMUM_CAPACITY >>> 1)) ?
               MAXIMUM_CAPACITY :
               tableSizeFor(initialCapacity + (initialCapacity >>> 1) + 1));
    // sizeCtl>0
    // 当size初始化的时候，sizeCtl表示初始化容量
    this.sizeCtl = cap;
}

// 根据一个 Map 集合来初始化
public ConcurrentHashMap(Map<? extends K, ? extends V> m) {
    // sizeCtl 设置为默认容量值
    this.sizeCtl = DEFAULT_CAPACITY;
    putAll(m);
}

// 指定初始化容量和负载因子
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();
    // 当指定的初始化容量initialCapacity 小于并发级别 concurrencyLevel的时候
    if (initialCapacity < concurrencyLevel)   // Use at least as many bins
        // 初始化容量的值设置为并发级别的值
        // 即，JDK1.8之后并发级别由散列表长度决定
        initialCapacity = concurrencyLevel;   // as estimated threads
    // 根据初始化容量和负载因子，去计算size
    long size = (long)(1.0 + (long)initialCapacity / loadFactor);
    // 根据size重新计算数组初始化容量
    int cap = (size >= (long)MAXIMUM_CAPACITY) ?
        MAXIMUM_CAPACITY : tableSizeFor((int)size);
    /**
     * sizeCtl > 0
     * 当目前table未初始化的时候， sizeCtl 表示初始化容量
     */
    this.sizeCtl = cap;
}

至此，ConcurrentHashMap 的源码分析准备工作就完成了，之后会更新其中一些较为麻烦的方法。

*吴聪聪*
关注
专栏目录
JDK1.8中的ConcurrentHashMap源码解析
d303577562的博客
03-29 365
1.底层结构 ConcurrentHashMap的底层结构和HashMap是一致的，都是使用的数组+链表+红黑树。 2.链表转化为红黑树的场景和原因 1.场景 在putVal()方法中，链表新增完一个节点的时候，会对链表长度进行判断，如果链表长度大于8（包含当前新增节点），并且数组长度大于等于64，则转化为红黑树，否则扩容。 final V putVal(K key, V value, boolean onlyIfAbsent) { if (key == null || value == null
JDK1.8 ConcurrentHashMap
A_BCDEF_的博客
03-01 622
将table分成n份 ，每份长度为stride，table大小除以CPU数量，平分给各个线程，每个线程对当前旧table中[transferIndex-stride, transferIndex-1]位置的结点进行迁移。迁移时不需要rehash，同hashmap一样计算新下标即可。JDK1.8 中采用CAS + synchronized，锁首节点，粒度更小。hash定位到node，复制节点前的链与节点后的链相连，跳过节点，即为删除。∵使用volatile修饰next，所以next值具有不变性，需要头插。
ConcurrentHashMap1.8源码分析
qq_15047415的博客
02-04 207
1. 查询get方法 1.1 tab位置如何定位 1.1.1 tableSizeFor方法： 在初始化时将tab长度n限制为2的N次方，图1（右）以n=41为例展示tableSizeFor方法的执行过程。 tableSizeFor方法 private static final int tableSizeFor(int c) { int n = c - 1; n |= n >>> 1; n |= n >>> 2; n |
Java1.8+ JUC包的ConcurrentHashMap源码分析
CodingAnHour
09-16 863
concurrentHashMap是一个支持高并发更新与查询的哈希表(基于HashMap)。在保证安全的前提下，进行检索不需要锁定。与hashtable不同，该类采用为什么get方法不需要加锁，可以保证线程安全的？ 因为 Node 的元素 val 和指针 next 是用 volatile修饰保证可见性和有效性，在多线程环境下synchronization+CAS的的方式保证线程操作的安全，同时synchronization锁的颗粒度更小，hashtable是方法级而synchronization是对象级别。
ConcurrentHashMap 1.8源码详解
weixin_44577346的博客
11-15 633
ConcurrentHashMap 1.8源码详解一、jdk1.8容器初始化 一、jdk1.8容器初始化 //没有进行任何操作，在添加数据时才会创建数组 public ConcurrentHashMap() { } //initialCapacity：指定数组初始长度(创建出的数组长度不是这个值) public ConcurrentHashMap(int initialCapacity) { if (initialCapacity < 0) thro
进阶一Promise源码
qq_38799074的博客
01-31 462
1.核心实现 let promise = new Promise((resolve,reject) => { resolve('ok'); reject('err') }) promise.then( (value) => {console.log(value);}, (err) => {console.log(err);} ) 根据Promise的使用方法得到一些信息： ①Promise就是一个类 在执行这个类的时候 需要传递一个回调函数进去 称之为执行器，执行器会立即执行
mac系统jdk1.8安装包！mac系统jdk1.8安装包！mac系统jdk1.8安装包！mac系统jdk1.8安装包！mac系
最新发布
03-11
mac系统jdk1.8安装包！mac系统jdk1.8安装包！mac系统jdk1.8安装包！mac系统jdk1.8安装包！mac系统jdk1.8安装包！mac系统jdk1.8安装包！mac系统jdk1.8安装包！mac系统jdk1.8安装包！mac系统jdk1.8安装包！mac系统jdk...
JDK1.8ConcurrentHashMap源码解析第二部分（添加元素、删除元素、扩容、查找元素）
weixin_43478710的博客
11-13 1165
ConcurrentHashMap源码解析第二部分，着重分析ConcurrentHashMap添加元素、删除元素、扩容、查找元素的具体流程 1、添加元素 添加元素用到的是putVal方法 public V put(K key, V value) { return putVal(key, value, false); } //onlyIfAbsent为true时找到相同节点不替换 为false就替换 final V putVal(K key, V value, boolean onlyIfA
jdk1.8 下载。 hotspot (包含源码)
07-17
JDK 1.8是Java 8版本的别称，这是一个重要的里程碑，因为它引入了许多创新特性，提升了开发效率和代码性能。 首先，JDK 1.8中的最大亮点之一是Lambda表达式。Lambda表达式是一种简洁的语法结构，用于表示无主体的...
jdk1.8 sun源码
09-13
这个"jdk1.8 sun源码"压缩包很可能包含了这些未公开的Sun Microsystems的源代码，使得开发者有机会深入研究Java平台的内部工作原理，这对于进行底层优化、理解和调试Java程序有着极大的帮助。然而，值得注意的是，...
JDK源码阅读计划(Day9) ConcurrentHashMap 非扩容，计数部分
小凯的博客
05-03 199
JDK11 我们可以看到ConcurrentHashMap实现了ConcurrentMap,Serializable这两个接口并且继承了AbstractMap这个抽象类。 实现与提供的操作和HashMap类似，都是哈希数组+链表/红黑树，但是key和value不能为null，并且是线程安全的，然而又不像HashTable用synchroinze锁表来保证线程安全，那样做的话效率太低了。 重要成员...
ConcurrentHashMap源码分析(1.8)
FYHannnnnn的博客
01-18 1754
0、说明  1、ConcurrentHashMap跟HashMap，HashTable的对比 2、ConcurrentHashMap原理概览 3、ConcurrentHashMap几个重要概念 4、ConcurrentHashMap几个重要方法 5、ConcurrentHashMap的初始化 6、ConcurrentHashMap的put操作详解 7、ConcurrentHashMap的扩容详解 8、ConcurrentHashMap的get操作详解 9、Con...
ConcurrentHashMap 1.8 源码分析
weixin_40849725的博客
07-12 614
ConcurrentHashMap源码分析一级目录二级目录三级目录 一级目录 二级目录 三级目录
JDK8 ConcurrentHashMap源码解析
我就是我的博客
01-24 683
文章目录常见属性释义常用小方法解析spread方法tableSizeFortabAt、casTabAt、setAtConcurrentHashMap(int initialCapacity)构造方法initTableForwardingNode构造函数put操作helpTransferaddCount()get操作 常见属性释义 //散列表数据最大容量 private static final int MAXIMUM_CAPACITY = 1 << 30; //散列表容量
ConcurrentHashMap详解（1.8）
ldj0816的博客
04-14 940
1.7和1.8的区别 1.8取消了segment分段锁的设计 增加了红黑树的实现 链表的长度大于8 且数组的长度大于64时，此时链表会转为红黑树，当扩容时，假设链表长度小于8 此时红黑树会转换成链表 初始化Tab -1 表示占位符，如果sizeCtl=-1 则表示已有线程抢到了初始化权限 大于0 数字 sizeCtl=sc = n*0.75 下次扩容的大小 负数（非-1） 代表有几个线程...
ConcurrentHashMap底层实现原理(JDK1.7 & 1.8)
jiohfgj的博客
08-16 491
ConcurrentHashMap底层实现原理(JDK1.7 & 1.8) 前言 我们都知道HashMap在多线程情况下，在put的时候，插入的元素超过了容量（由负载因子决定）的范围就会触发扩容操作，就是rehash，这个会重新将原数组的内容重新hash到新的扩容数组中，在多线程的环境下，存在同时其他的元素也在进行put操作，如果hash值相同，可能出现同时在同一数组下用链表表示，造成闭环，导致在get时会出现死循环，所以HashMap是线程不安全的。 我们来了解另一个键值存储集合HashTable
ConcurrentHashMap源码分析
Apple_Andy的博客
02-07 226
一、jdk1.8容器初始化 1、源码分析 在jdk8的ConcurrentHashMap中一共有5个构造方法，这五个构造方法中都没有对内部的数组做初始化， 只是对一些变量的初始值做了处理 //没有维护任何变量的操作，如果调用该方法，数组长度默认是16 public ConcurrentHashMap() { } 注意，调用可以传递初始容量的构造方法，得到的初始容量和HashMap以及jdk7的ConcurrentHashMap不同，即使你传递的是一个2的幂次方数，该方法计算出来的初始容量依然是
《Java源码分析》：ConcurrentHashMap JDK1.8
热门推荐
wojiushimogui的博客
08-07 1万+
《Java源码分析》：ConcurrentHashMap JDK1.8最近一直在看关于J.U.C中的源码，了解原子操作，了解锁机制，了解多线程并发等等。但是ConcurrentHashMap一直拖着到今天才算告一段落。也要感谢ConcurrentHashMap这个类，刚开始就是想弄懂里面的工作原理，但是，无奈看了网上关于介绍ConcurrentHashMap这个类的资料或博客都是基于JDK1.8以
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值