2-2-3-9-2-2、jdk1.8ConcurrentHashMap详解

数据结构

和jdk1.8的HashMap一样，使用的是数组+链表+红黑树的结构
1、HashMap详解

源码分析

重要常量

/**
 * 默认最大容量
 */
private static final int MAXIMUM_CAPACITY = 1 << 30;

/**
 * 默认初始化数组容量=16 . 即默认有16个bucket
 */
private static final int DEFAULT_CAPACITY = 16;

/**
 * 最大数组长度 Integer的最大值 - 8 的长度
 */
static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

/**
 * 默认的并发级别:16 . 即最多允许16个线程并发 ..
 * jdk1.7中采用的是分段锁并发访问处理 . 此方式有很大的局限性
 * jdk1.8中放弃了锁分段的做法 , 采用了CAS+synchronized方式处理并发 .
 */
private static final int DEFAULT_CONCURRENCY_LEVEL = 16;

/**
 * 扩容时的触发条件 . 即负载因子. 当达到当前容量 * 0.75时 , 进行扩容
 */
private static final float LOAD_FACTOR = 0.75f;

/**
 * 树形化阈值.当链表长度达到8时 , 转换为树形结构
 */
static final int TREEIFY_THRESHOLD = 8;

/**
 * 当树结构中的节点数量达到6时 , 红黑树结构转换为链表结构
 */
static final int UNTREEIFY_THRESHOLD = 6;

/**
 * 最小树形化需要的数组长度 . 达不到该值时 , 只进行扩容操作
 */
static final int MIN_TREEIFY_CAPACITY = 64;

/**
 * table进行扩容时 , 每个线程最小迁移的table的槽位数 .
 * 扩容时 , 在最大容量范围内 , 容量都是以2倍的方式进行 . 初始时容量16 , 则最小迁移槽位是16
 */
private static final int MIN_TRANSFER_STRIDE = 16;

/**
 * 作为偏移量参与和线程数量的标记数
 */
private static int RESIZE_STAMP_BITS = 16;

/**
 * 允许执行扩容的最大线程数
 */
private static final int MAX_RESIZERS = (1 << (32 - RESIZE_STAMP_BITS)) - 1;

/**
 * 扩容阈值计算时的偏移量-default = 16
 */
private static final int RESIZE_STAMP_SHIFT = 32 - RESIZE_STAMP_BITS;

内部静态方法

/**
 * 位运算 . 通过移位降低Hash碰撞的风险
 *
 * @param h
 * @return
 */
private static final int spread(int h) {
    return (h ^ (h >>> 16)) & HASH_BITS;
}

/**
 * 通过位运算将传入的数据换算为2的N次方的数值
 */
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;
}

/**
 * 判断对象是否实现compare接口 ,
 * 若实现 : 返回对象类型 .
 * 否则 : 返回null
 * @param x
 * @return
 */
static Class<?> comparableClassFor(Object x) {
    if (x instanceof Comparable) {
        Class<?> c;
        Type[] ts, as;
        Type t;
        ParameterizedType p;
        if ((c = x.getClass()) == String.class)
            //若为字符串 . 返回string
            return c;
        if ((ts = c.getGenericInterfaces()) != null) {
            //循环类x实现的所有接口
            for (int i = 0; i < ts.length; ++i) {
                if (((t = ts[i]) instanceof ParameterizedType) &&
                        ((p = (ParameterizedType) t).getRawType() ==
                                Comparable.class) &&
                        (as = p.getActualTypeArguments()) != null &&
                        as.length == 1 && as[0] == c) // type arg is c
                    return c;
            }
        }
    }
    return null;
}

/**
 * 如果x与kc（k）类型匹配 ，则返回 k.compareTo（x）对比值，若x为空或者类型不匹配 . 直接返回0
 */
@SuppressWarnings({"rawtypes", "unchecked"}) // for cast to Comparable
static int compareComparables(Class<?> kc, Object k, Object x) {
    return (x == null || x.getClass() != kc ? 0 :
            ((Comparable) k).compareTo(x));
}

/* ---------------- Table element access -------------- */

/**
 * 寻找指定数组在内存中i位置的内容
 * getObjectVolatile(): 获取obj对象中offset偏移地址对应的tab的field值,支持volatile load语义
 * ABASE : 起始位置
 *
 * @param tab 指定的数组
 * @param i   位置
 * @param <K>
 * @param <V>
 * @return
 */
@SuppressWarnings("unchecked")
static final <K, V> Node<K, V> tabAt(Node<K, V>[] tab, int i) {
    return (Node<K, V>) U.getObjectVolatile(tab, ((long) i << ASHIFT) + ABASE);
}

/**
 * 比较并替换
 *
 * @param tab 包含要替换对象的数组
 * @param i   字段在对象内的下标,用于计算对象地址偏移量
 * @param c   期望的值
 * @param v   若当前值等于期望的值,进行替换 .用于进行更新替换的值
 * @param <K>
 * @param <V>
 * @return
 */
static final <K, V> boolean casTabAt(Node<K, V>[] tab, int i,
                                     Node<K, V> c, Node<K, V> v) {
    //native 方法 . 采用C++实现
    // 通过我们传入的字段在对象中的偏移量,来获取到字段的地址(包括首地址+偏移量)
    // 通过对比两个字段的地址是否相同.若相同,则使用v的地址进行替换
    return U.compareAndSwapObject(tab, ((long) i << ASHIFT) + ABASE, c, v);
}

/**
 * 设置数组中某个下标处的值
 *
 * @param tab 数组对象
 * @param i   字段在对象内的下标,用于计算对象地址偏移量
 * @param v   要设置的值
 * @param <K>
 * @param <V>
 */
static final <K, V> void setTabAt(Node<K, V>[] tab, int i, Node<K, V> v) {
    U.putObjectVolatile(tab, ((long) i << ASHIFT) + ABASE, v);
}

重要成员变量

/**
 * 在第一次插入数据时才会延迟初始化
 * 大小总是二的幂次方。由迭代器直接访问。
 * 为线程共享变量
 */
transient volatile Node<K, V>[] table;

/**
 * 下一个要使用的数组,只有在扩容时才不为空
 * 线程共享变量
 */
private transient volatile Node<K, V>[] nextTable;

/**
 * 基本计数器,主要在没有争用时使用,但在数组初始化竞争期间用作比对回退参考值.更新通过CAS-共享变量
 */
private transient volatile long baseCount;

/**
 * 表初始化和调整控件大小。如果为负值，则表正在初始化或调整大小：-1用于初始化，若为>= 1 : 活动调整大小线程的数量
 * 否则，当table为null时，将保留创建时使用的初始表大小，默认值为0。初始化后，保存下一个要调整表大小的元素计数值。-共享变量
 */
private transient volatile int sizeCtl;

/**
 * 扩容时要分割的下一个表的索引-共享变量
 */
private transient volatile int transferIndex;

/**
 * Spinlock (locked via CAS) used when resizing and/or creating CounterCells.
 * 扩容或者创建计数器单元格时使用的自旋锁(通过CAS锁定)-共享变量,用来标记当前数组是否在初始化或者扩容
 */
private transient volatile int cellsBusy;

/**
 * 计数器数组。
 * 非空时，大小为2的幂次方。
 * 并发情况下,采用分段并发,每个值记录每个段的数据的长度.
 * 计算总量时,将数组的值累加求和即为当前集合的总节点数
 */
private transient volatile CounterCell[] counterCells;

构造函数

/**
 * Creates a new, empty map with the default initial table size (16).
 * 构造器,创建一个空的map对象 , 默认带长度[16]的数组
 */
public ConcurrentHashMap() {
}

/**
 * 构造器, 创建一个新的空map,可指定其初始化的数组的大小 . 而不需动态调增
 */
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;
}

/**
 * 根据入参的map集合类型,创建一个相同的map集合 , 并初始化数据
 *
 * @param m the map
 */
public ConcurrentHashMap(Map<? extends K, ? extends V> m) {
    this.sizeCtl = DEFAULT_CAPACITY;
    putAll(m);
}

/**
 * 构造器
 * @param initialCapacity 初始化容量
 * @param loadFactor      加载因子
 */
public ConcurrentHashMap(int initialCapacity, float loadFactor) {
    this(initialCapacity, loadFactor, 1);
}

/**
 * 构造器
 * @param initialCapacity  初始化容量
 * @param loadFactor       加载因子
 * @param concurrencyLevel 并发级别--default = 16
 */
public ConcurrentHashMap(int initialCapacity,
                           float loadFactor, int concurrencyLevel) {
    if (!(loadFactor > 0.0f) || initialCapacity < 0 || concurrencyLevel <= 0)
        throw new IllegalArgumentException();
    if (initialCapacity < concurrencyLevel)   // 尽可能少的使用concurrencyLevel
        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;
}

确保当前table的大小为2的N次方

/**
 * 通过位运算将传入的数据换算为>=c的2的N次方的数值
 * 如 :
 *   入参: 8 .return 8
 *   入参: 10 .return 16
 *   入参: 17 .return 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;
}

put操作

/**
 *  put and putIfAbsent
 */
final V putVal(K key, V value, boolean onlyIfAbsent) {
    //key & value 不为null
    if (key == null || value == null) throw new NullPointerException();

    //计算偏移量-类似于计算hashcode.[将结果值控制在Integer.max范围内]
    int hash = spread(key.hashCode());
    int binCount = 0;
    //死循环处理,直到插入成功
    for (Node<K, V>[] tab = table; ; ) {
        Node<K, V> f;
        int n, i, fh;
        //若当前数组table为空 . 则进行初始化
        if (tab == null || (n = tab.length) == 0)
            //初始化node数组
            tab = initTable();
            //根据key的hash值计算key在table中的下标i,取出该节点赋值给f
        else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
            //i = (n - 1) & hash 等同于 i=hash%n(前提是n等于2的幂次方)
            //如果table[i]==null(没有发生碰撞 即该位置的节点为空),
            //直接利用CAS操作将该value存储在该位置,若CAS成功,直接退出死循环
            if (casTabAt(tab, i, null,
                    new Node<K, V>(hash, key, value, null)))
                break;                   // 当添加到空的bin时不上锁
        }
        //若节点位置不为空 , 说明map中该位置已存在节点
        //若table[i]节点的hash值为-1 , 说明当前map正在扩容 , 这时当前线程会帮助执行扩容以加快速度并返回扩容后的新的数组
        else if ((fh = f.hash) == MOVED)
            //帮助扩容
            tab = helpTransfer(tab, f);
        else {
            //table[i]的节点的hash值不等于MOVED[-1] ,说明当前不是处于扩容状态
            V oldVal = null;
            //锁住节点f[在上面的处理中说明逻辑执行到这里时节点f不为null],在加锁期间不允许其他线程操作
            //synchronized (f)也实现了线程安全,确保该节点不会被其他线程操作处理 .
            // 但也只是锁住该节点.该数组下其他的数据不受影响,也支持并发处理
            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;
                                break;
                            }
                            //若查询链表没有同样的key , 则直接将数据插入到链表尾部 , 并跳出循环
                            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 MyConcurrentHashMap.TreeBin) {
                        //如果table[i]为树节点，将节点node转成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;
                        }
                    }
                }
            }
            if (binCount != 0) {
                //链表结构中新增节点时,变量binCount才会依次新增,红黑树结构中添加节点时,binCount = 2;
                //binCount >= TREEIFY_THRESHOLD[8]: 判断是否达到树形化阈值条件 . 将链表结构转变为红黑树
                //binCount = 2;表示当前已经是树形化结构了
                if (binCount >= TREEIFY_THRESHOLD)
                {
                    treeifyBin(tab, i);
                }
                if (oldVal != null)
                //若当前节点的旧value不为空,插入成功后返回oldVal
                {
                    return oldVal;
                }
                break;
            }
        }
    }
    //节点计数器+1
    addCount(1L, binCount);
    return null;
}

初始化数组

在高并发的场景下，initTable()方法通过cas(compareAndSwapInt)的机制来保证只有一个线程能够成功初始化。其他线程放弃本次循环的cpu竞争，进行自旋。但是这样有可能导致cpu占有率过高的问题？比如：一个线程本次循环放弃竞争，但是第二次循环又竞争到了cpu,依次叠加，就会导致cpu占有率过高甚至百分之百的问题

/**
 * 使用sizeCtl中记录的值初始化数组
 */
private final Node<K, V>[] initTable() {
    Node<K, V>[] tab;
    int sc;
    // 执行条件 , 当前数组table为空或者长度为0
    while ((tab = table) == null || tab.length == 0) {
        //若sizeCtl[偏移量-用于计算字段在数组中的地址]小于0.执行Thread.yield():使当前线程由执行状态，变成为就绪状态，让出cpu时间，
        // 在下一个线程执行时候，此线程有可能被执行，也有可能没有被执行。
        if ((sc = sizeCtl) < 0)
            Thread.yield();
            //将偏移量设置为-1,表明当前正在执行初始化 . 后续线程将被挂起进入就绪状态.
        else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
            //初始化数组长度,并替换当前sizeCtl的值用于后续扩容
            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;
}

辅助扩容

/**
 * 帮助执行扩容
 * 关于 sizeCtl 变量：
 * -1 :代表table正在初始化,其他线程应该交出CPU时间片; -N: 表示正有N-1个线程执行扩容操作（高 16 位是 length 生成的标识符，低 16 位是扩容的线程数）
 * 大于 0: 如果table已经初始化,代表table容量,默认为table大小的0.75,如果还未初始化,代表需要初始化的大小
 *
 * @param tab 当前table数组
 * @param f   当前槽位的变量
 * @return
 */
final Node<K, V>[] helpTransfer(Node<K, V>[] tab, Node<K, V> f) {
    Node<K, V>[] nextTab;
    int sc;
    //数据校验 : table数组不为空 , 且node节点为转移类型 , 且node节点的nextTable不为空. 尝试帮助扩容
    if (tab != null && (f instanceof MyConcurrentHashMap.ForwardingNode) &&
            (nextTab = ((ForwardingNode<K, V>) f).nextTable) != null) {
        //根据数组长度计算得到一个标识符号
        int rs = resizeStamp(tab.length);
        //如果nextTab和tab没有被并发修改,且sizeCtl < 0[表示正在扩容],
        while (nextTab == nextTable && table == tab &&
                (sc = sizeCtl) < 0) {
            //如果sizeCtl无符号右移16位不等于rs[即若sc的前16位不等于标识符,说明标识符发生了变化.这时将结束执行]
            //或者若sc = rs + 1,说明sc此时为非负数,表示此时扩容已结束
            //或者sc = rs + 65535[允许的最大帮助线程数量],不在执行
            //或者transferIndex <= 0[转移下标发生了调整,扩容结束]
            //满足上述一点,结束循环,返回table
            if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
                    sc == rs + MAX_RESIZERS || transferIndex <= 0)
                break;
            //将SIZECTL + 1,表示此时辅助扩容的线程又多了一个 . SIZECTL为共享变量,可以在其他线程执行时实时读取到.起到线程间通知的效果
            if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1)) {
                //转移节点
                transfer(tab, nextTab);
                break;
            }
        }
        return nextTab;
    }
    return table;
}

节点计数器

/**
 * 从 putVal 传入的参数是 1， binCount，binCount 默认是0，只有 hash 冲突了才会大于 1.且他的大小是链表的长度（如果不是红黑数结构的话）12
 * @param x     the count to add
 * @param check if <0, don't check resize, if <= 1 only check if uncontended
 */
private final void addCount(long x, int check) {
    CounterCell[] as;
    long b, s;
    //首先if判断counterCells为空并且对当前map对象cas操作baseCount + x成功，就跳过if里的操作，
    //因为都cas操作baseCount + x成功了，就不需要通过counterCells辅助了，简单明了。
    if ((as = counterCells) != null ||
        !U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) {
        CounterCell a; long v; int m;
        boolean uncontended = true;
        //如果上面判断失败了，counterCells不为空 或者counterCells为空但cas失败了。
        //如果counterCells为空，直接执行fullAddCount。
        //如果不为空,判断当前线程在counterCells中的槽位是否为空，如果不为空，
        //对槽位中的CounterCell对象cas操作value加1，成功return,失败执行fullAddCount，如果槽位为空，直接执行fullAddCount
        if (as == null || (m = as.length - 1) < 0 ||
            //ThreadLocalRandom.getProbe()就相当于是 [当前线程的哈希值]
            (a = as[ThreadLocalRandom.getProbe() & m]) == null ||
            !(uncontended =
              //cas对CounterCell对象中的value执行+x(也就是+1)操作
              U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))) {
            fullAddCount(x, uncontended);
            return;
        }
        if (check <= 1)
            return;
        s = sumCount();
    }
    if (check >= 0) {
        Node<K, V>[] tab, nt;
        int n, sc;
        while (s >= (long) (sc = sizeCtl) && (tab = table) != null &&
                (n = tab.length) < MAXIMUM_CAPACITY) {
            int rs = resizeStamp(n);
            if (sc < 0) {
                if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
                        sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
                        transferIndex <= 0)
                    break;
                if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
                    transfer(tab, nt);
            } else if (U.compareAndSwapInt(this, SIZECTL, sc,
                    (rs << RESIZE_STAMP_SHIFT) + 2))
                transfer(tab, null);
            s = sumCount();
        }
    }
}

判断逻辑如下：
先判断CounterCell数组是否为空:

1. 如果为空则对当前map对象cas操作 baseCount 加 1，cas成功了就跳过if，失败了就执行fullAddCount方法
2. 如果不为空则通过当前线程的hash值找到此线程在CounterCell数组中对应的位置
   1. 如果此位置的CounterCell对象为空，就执行fullAddCount方法
   2. 如果不为空就对此CounterCell对象cas操作value加1
      1. 如果成功return
      2. 失败就执行fullAddCount方法
         

fullAddCount代码块

private final void fullAddCount(long x, boolean wasUncontended) {
    int h;
    //如果当前线程hash值==0，则重新生成一个hash值。
    //当前线程生成的hash值不会改变
    if ((h = ThreadLocalRandom.getProbe()) == 0) {
        ThreadLocalRandom.localInit();      // force initialization
        h = ThreadLocalRandom.getProbe();
        wasUncontended = true;
    }
    boolean collide = false;                // True if last slot nonempty
    //循环
    for (;;) {
        CounterCell[] as; CounterCell a; int n; long v;
        //如果counterCells已经被初始化了
        if ((as = counterCells) != null && (n = as.length) > 0) {
            //如果当前线程对应于counterCell数组中的槽位为空
            if ((a = as[(n - 1) & h]) == null) {
                //如果没有其他线程操作对应counterCell数组中的槽位
                if (cellsBusy == 0) { 
                    //counterCell数组中为空的槽位中创建一个CounterCell对象        
                    CounterCell r = new CounterCell(x); 
                    //如果将cellsBusy成功修改成1 
                    if (cellsBusy == 0 &&
                        U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
                        boolean created = false;
                        try { 
                           //再次校验有没有其他线程操作该数组槽位
                            CounterCell[] rs; int m, j;
                            if ((rs = counterCells) != null &&
                                (m = rs.length) > 0 &&
                                rs[j = (m - 1) & h] == null) {
                                rs[j] = r;
                                //标记创建成功
                                created = true;
                            }
                        } finally {
                            cellsBusy = 0;
                        }
                        if (created)
                            break;
                        continue;           // Slot is now non-empty
                    }
                }
                collide = false;
            }
            //wasUncontended一直为true
            else if (!wasUncontended)       // CAS already known to fail
                wasUncontended = true;      // Continue after rehash
            //如果当前线程对应槽位已经存在CounterCell元素了，就对value+x
            else if (U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))
                break;
            //不扩容条件
            else if (counterCells != as || n >= NCPU)
                collide = false;            // At max size or stale
            //为扩容做条件 
            else if (!collide)
                collide = true;
           //一个线程循环两次，都没有加1成功的情况下，数组扩容
           //在collide = true的情况下，数组扩容
            else if (cellsBusy == 0 &&
                     U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
                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
            }
            //当前线程重新生成的hash值
            h = ThreadLocalRandom.advanceProbe(h);
        }
        //如果counterCells 没有被初始化，
        // cellsBusy==0表示没有其他线程在使用counterCells数组。
        else if (cellsBusy == 0 && counterCells == as &&
                 U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {//表示该数组已经有线程在用
            boolean init = false;
            try {  
                //初始化数组                         
                if (counterCells == as) {
                    //初始化长度为2
                    CounterCell[] rs = new CounterCell[2];
                    rs[h & 1] = new CounterCell(x);
                    counterCells = rs;
                    init = true;
                }
            } finally {
                //表示当前线程已经操作完成该数组
                cellsBusy = 0;
            }
            if (init)
                break;
        }
        //如果都不满足，则线程自旋去竞争baseCount和CounterCell
        else if (U.compareAndSwapLong(this, BASECOUNT, v = baseCount, v + x))
            break;                          // Fall back on using base
    }
}

插入树节点

/**
 *红黑树结构中新增节点数据
 *
 * @return null if added
 */
final TreeNode<K, V> putTreeVal(int h, K k, V v) {
    Class<?> kc = null;
    boolean searched = false;
    //从根节点开始寻找
    for (TreeNode<K, V> p = root; ; ) {
        int dir, ph;
        K pk;
        if (p == null) {
            //若根节点为空,则初始化将数据插入,并跳出循环
            first = root = new TreeNode<K, V>(h, k, v, null, null);
            break;
        } else if ((ph = p.hash) > h)
            //若新增数据的hash值<根节点,dir = -1,插入到左子节点
            dir = -1;
        else if (ph < h)
            //若新增数据的hash值> 根节点,dir = 1,插入到右子节点
            dir = 1;
        else if ((pk = p.key) == k || (pk != null && k.equals(pk)))
            //若根节点key同入参key对象地址或者内容相同[如string/int]
            return p;
        else if ((kc == null &&
                (kc = comparableClassFor(k)) == null) ||
                (dir = compareComparables(kc, k, pk)) == 0) {
            //若key不是对象类型并且未实现compare接口或者dir==0[无法比较两者hash值的大小]
            if (!searched) {
                TreeNode<K, V> q, ch;
                searched = true;
                if (((ch = p.left) != null &&
                        (q = ch.findTreeNode(h, k, kc)) != null) ||
                        ((ch = p.right) != null &&
                                (q = ch.findTreeNode(h, k, kc)) != null))
                    //从树结构中左右节点找到匹配的子节点
                    return q;
            }
            //对比得到应该往左子树还是右子树中插入
            dir = tieBreakOrder(k, pk);
        }

        TreeNode<K, V> xp = p;
        //dir>0 : 往右子节点寻找插入, dir<=0 : 左子节点插入
        //子节点为空
        if ((p = (dir <= 0) ? p.left : p.right) == null) {
            //first:线程共享变量
            TreeNode<K, V> x, f = first;
            first = x = new TreeNode<K, V>(h, k, v, f, xp);
            if (f != null)
                f.prev = x;
            if (dir <= 0)
                xp.left = x;
            else
                xp.right = x;
            if (!xp.red)
                //红黑树中不可有两个连续的红节点 . 若xp为黑色 . 则x可标注为红色
                x.red = true;
            else {
                //CAS锁住执行红黑树结构平衡
                lockRoot();
                try {
                    //插入后用于维持红黑树结构性质的修复操作，
                    root = balanceInsertion(root, x);
                } finally {
                    unlockRoot();
                }
            }
            break;
        }
    }
    assert checkInvariants(root);
    return null;
}

平衡红黑树的结构

/**
 * 插入后用于维持红黑树性质的修复操作，
 * @param root
 * @param x
 * @param <K>
 * @param <V>
 * @return
 */
static <K,V> TreeNode<K,V> balanceInsertion(TreeNode<K,V> root,
                                            TreeNode<K,V> x) {
    x.red = true;//插入的结点设为红色
    for (TreeNode<K,V> xp, xpp, xppl, xppr;;) {
        if ((xp = x.parent) == null) {
            x.red = false;//x的父亲为null代表x是根结点，x改黑色直接结束
            return x;
        }
        else if (!xp.red || (xpp = xp.parent) == null)
            return root;//若x的父结点为黑色或者x的父亲为根结点(实际上根应该是黑色)插入红色结点不影响红黑树性质
        if (xp == (xppl = xpp.left)) {
            if ((xppr = xpp.right) != null && xppr.red) {
                //xppr为x的叔叔，且叔叔为红色，x的叔叔和父亲改为红色，x的爷爷改为黑色，x指针上移到爷爷的位置
                xppr.red = false;
                xp.red = false;
                xpp.red = true;
                x = xpp;
            }
            else {
                if (x == xp.right) {
                    //情况2，x的叔叔是黑色且x是右儿子。对x上升至父亲后执行一次左旋
                    root = rotateLeft(root, x = xp);
                    xpp = (xp = x.parent) == null ? null : xp.parent;
                }
                if (xp != null) {
                    //情况3，x的叔叔是黑色且x是左儿子。x的父亲改黑色，x的爷爷改红色后对x的爷爷进行右旋
                    xp.red = false;
                    if (xpp != null) {
                        xpp.red = true;
                        root = rotateRight(root, xpp);
                    }
                }
            }
        }
        else {//以下为对称的操作.平衡红黑树的节点数
            if (xppl != null && xppl.red) {
                xppl.red = false;
                xp.red = false;
                xpp.red = true;
                x = xpp;
            }
            else {
                if (x == xp.left) {
                    //右旋
                    root = rotateRight(root, x = xp);
                    xpp = (xp = x.parent) == null ? null : xp.parent;
                }
                if (xp != null) {
                    xp.red = false;
                    if (xpp != null) {
                        xpp.red = true;
                        //左旋
                        root = rotateLeft(root, xpp);
                    }
                }
            }
        }
    }
}

链表转红黑树

/**
 * 数组中index下的链表数据进行树形化转换
 */
private final void treeifyBin(Node<K, V>[] tab, int index) {
    Node<K, V> b;
    int n, sc;
    if (tab != null) {
        //若当前数组长度<64.
        if ((n = tab.length) < MIN_TREEIFY_CAPACITY)
            //n <<1 = n*2 对table进行扩容
            tryPresize(n << 1);
        else if ((b = tabAt(tab, index)) != null && b.hash >= 0) {
            synchronized (b) {
                if (tabAt(tab, index) == b) {
                    TreeNode<K, V> hd = null, tl = null;
                    //1.取出下标index的数据节点
                    //2.依次循环将Node节点对象转为TreeNode
                    for (Node<K, V> e = b; e != null; e = e.next) {
                        TreeNode<K, V> p =
                                new TreeNode<K, V>(e.hash, e.key, e.val,
                                        null, null);
                        if ((p.prev = tl) == null)
                            //若节点P的父节点数据为空,p为该树结构的头节点
                            hd = p;
                        else
                            //不然,将tl的下节点设置为P
                            tl.next = p;
                        //重置tl临时变量,便于下次循环处理prev/next[上下节点指针]
                        tl = p;
                    }
                    //重设数组数据
                    setTabAt(tab, index, new TreeBin<K, V>(hd));
                }
            }
        }
    }
}

数组扩容

/**
 * 扩容
 */
private final void tryPresize(int size) {
    //size + (size >>> 1) + 1 : 8 + (8/2) + 1
    //tableSizeFor : 15->16 . 7->8 . 8->8
    int c = (size >= (MAXIMUM_CAPACITY >>> 1)) ? MAXIMUM_CAPACITY :
            tableSizeFor(size + (size >>> 1) + 1);
    int sc;
    while ((sc = sizeCtl) >= 0) {
        Node<K, V>[] tab = table;
        int n;
        //若当前table为空,则初始化,采用CAS算法自旋确保并发
        if (tab == null || (n = tab.length) == 0) {
            n = (sc > c) ? sc : c;
            if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
                try {
                    if (table == tab) {
                        @SuppressWarnings("unchecked")
                        Node<K, V>[] nt = (Node<K, V>[]) new Node<?, ?>[n];
                        table = nt;
                        sc = n - (n >>> 2);
                    }
                } finally {
                    sizeCtl = sc;
                }
            }
        } else if (c <= sc || n >= MAXIMUM_CAPACITY)
            //若已超出最大值.直接退出
            break;
        else if (tab == table) {
            int rs = resizeStamp(n);
            if (sc < 0) {
                Node<K, V>[] nt;
                if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
                        sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
                        transferIndex <= 0)
                    break;
                if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
                    //数据迁移
                    transfer(tab, nt);
            } else if (U.compareAndSwapInt(this, SIZECTL, sc,
                    (rs << RESIZE_STAMP_SHIFT) + 2))
                transfer(tab, null);
        }
    }
}

/**
 * Integer.numberOfLeadingZeros(n)  : 给定一个int类型数据，返回这个数据的二进制串中从最左边算起连续的“0”的总数量。
 * 因为int类型的数据长度为32所以高位不足的地方会以“0”填充。
 * 1 << (RESIZE_STAMP_BITS - 1) : 1左移一定位数 . 这里RESIZE_STAMP_BITS作为偏移量使用
 */
static final int resizeStamp(int n) {
    return Integer.numberOfLeadingZeros(n) | (1 << (RESIZE_STAMP_BITS - 1));
}

get操作

/**
 * get方法 . 若key为空 . 抛空指针异常
 */
public V get(Object key) {
    Node<K, V>[] tab;
    Node<K, V> e, p;
    int n, eh;
    K ek;
    //位运算.求key的hash值
    int h = spread(key.hashCode());
    //若当前table节点数组不为空,且节点值不为null
    if ((tab = table) != null && (n = tab.length) > 0 &&
            (e = tabAt(tab, (n - 1) & h)) != null) {
        if ((eh = e.hash) == h) {
            //两种条件判断 : 1.入参key与数组当前偏移量处的对象地址相同 . 2.对象内容相同,则认为当前节点即为目标节点
            if ((ek = e.key) == key || (ek != null && key.equals(ek)))
                return e.val;
        } else if (eh < 0)
            //若目标节点的hash值<0,则从当前节点处,向下寻找,直到满足key的地址相同或者对象内容相同
            return (p = e.find(h, key)) != null ? p.val : null;
        //hash值相同 , 但不满足对象地址相同或者内容相同的情况下 , 沿着数组当前节点向下[链表或者红黑树]寻找 . 直到满足条件
        while ((e = e.next) != null) {
            if (e.hash == h && ((ek = e.key) == key || (ek != null && key.equals(ek))))
                return e.val;
        }
    }
    return null;
}

size方法

size方法最后返回 baseCount属性 加上CounterCell数组里面的所有值的和

public int size() {
    long n = sumCount();
    return ((n < 0L) ? 0 :
            (n > (long)Integer.MAX_VALUE) ? Integer.MAX_VALUE :
            (int)n);
}

//再看看 sumCount()
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;
}

CounterCell是一个静态内部类，里面的long属性是通过volatile 修饰，来保证并发是当前类型数据的可见性

@sun.misc.Contended static final class CounterCell {
    volatile long value;
    CounterCell(long x) { value = x; }
}
 /**
   * Table of counter cells. When non-null, size is a power of 2.
   * 计数器单元表。当非空时，大小是2的乘方。
  */
private transient volatile CounterCell[] counterCells;