jdk1.8ConcurrentHashMap源码学习

ConcurrentHashMap解析:很多方法和hashMap的方法一样 . 因此这里重点分析了其中的get/put相关的一些方法,若需要hashMap的源代码注释解读的,可参考另一篇jdk1.8hashMap源码分析

1. 类说明及相关变量解读

/**
 * concurrentHashMap源码分析
 * 数据结构 : 同HashMap一样 , 也是采用的数组 + 链表 + 红黑树的结构
 * 并发控制 : 通过CAS + synchronized + Unsafe类直接操作地址的方式
 * 并发粒度 : 定位到了桶上而不是节点上 . 即一个链表或者红黑树结构同时只支持一个线程操作 .
 * JDK1.7说明 : 采用ReentrantLock(Segment)即分段锁来实现并发控制 , 但是最多支持16个并发线程
 * <p>
 * 对比
 * 1. synchronized是属于底层的实现 . 而ReentrantLock继承于AQS(AbstractQueueSynchronizer).还是属于代码层面的阻塞与唤醒
 * 2. HashMap中是允许存在null的key和value的 . ConcurrentHashMap 中则不允许.若出现该情况 , 将抛出空指针异常
 * 差异存在的理由:
 * HashMap : 本身是没有对多线程的支持的 , 也就是说其本身就是假定为单线程中正确执行 , 通过key获取对应的值(value) ,
 *           通过containsKey(key)方法判断key是否存在
 * ConcurrentHashMap: 本身设计之初是为了支持高并发的 . 假如集合中此时有一个key=null && value=null的键值对 ,
 *           线程A通过containsKey(key)判断该node存在 , 在执行get(key)之前线程B将该节点删除 , 此时节点不存在 , 返回虽然也是null,
 *           但是其表示的是该节点对应的value已经不存在 , 而不是value = null . 存在语义差异 .源代码中开发者的注释中,
 *           作者也只是对value不能为null考虑到并发二语义情况的说明 ,  并没有说明key为什么不能为null . 大概是考虑到统一标准或者同样二语义吧 .
 * test
 * @param <K>
 * @param <V>
 */
public class MyConcurrentHashMap<K, V> extends AbstractMap<K,V> implements ConcurrentMap<K, V>, Serializable {
    private static final long serialVersionUID = 7249069246763182397L;

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

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

    /**
     * 最大数组长度 8 = '_length='的长度
     */
    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;

    /*
     * Encodings for Node hash fields. See above for explanation.
     */
    static final int MOVED = -1; // hash for forwarding nodes
    static final int TREEBIN = -2; // hash for roots of trees
    static final int RESERVED = -3; // hash for transient reservations
    static final int HASH_BITS = 0x7fffffff; // usable bits of normal node hash

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

    /**
     * 执行序列化时要包含的对象域
     */
    private static final ObjectStreamField[] serialPersistentFields = {
            //分段锁对象初始化 . 兼容JDK1.7中的JDK实现
            new ObjectStreamField("segments", Segment[].class),
            new ObjectStreamField("segmentMask", Integer.TYPE),
            new ObjectStreamField("segmentShift", Integer.TYPE)
    };

    /* ---------------- Nodes -------------- */

    /**
     * 节点链表对象封装 ,特殊处理 :key-value均不能为null ,且不提供手动set节点value的方法[大概是为了防止并发问题]
     *
     * @param <K>
     * @param <V>
     */
    static class Node<K, V> implements 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;
        }

        @Override
        public final K getKey() {
            return key;
        }

        @Override
        public final V getValue() {
            return val;
        }

        @Override
        public final int hashCode() {
            return key.hashCode() ^ val.hashCode();
        }

        @Override
        public final String toString() {
            return key + "=" + val;
        }

        //不支持直接手动操作节点内容
        @Override
        public final V setValue(V value) {
            throw new UnsupportedOperationException();
        }

        /**
         * 对象地址相同或者对象内容相同
         * @param o
         * @return
         */
        public final boolean equals(Object o) {
            Object k, v, u;
            Entry<?, ?> e;
            return ((o instanceof Map.Entry) &&
                    (k = (e = (Entry<?, ?>) o).getKey()) != null &&
                    (v = e.getValue()) != null &&
                    (k == key || k.equals(key)) &&
                    (v == (u = val) || v.equals(u)));
        }

        /**
         * Map中的get(key)方法,获取key=k && key.hashCode = h 的节点
         */
        Node<K, V> find(int h, Object k) {
            Node<K, V> e = this;
            if (k != null) {
                do {
                    K ek;
                    if (e.hash == h &&
                            ((ek = e.key) == k || (ek != null && k.equals(ek))))
                        return e;
                } while ((e = e.next) != null);
            }
            return null;
        }
    }

    /* ---------------- Static utilities -------------- */


    /**
     * 位运算 . 通过移位降低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);
    }

    /* ---------------- Fields -------------- */

    /**
     * 在第一次插入数据时才会延迟初始化
     * 大小总是二的幂次方。由迭代器直接访问。
     * 为线程共享变量
     */
    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;

    // views
    private transient KeySetView<K, V> keySet;
    private transient ValuesView<K, V> values;
    private transient EntrySetView<K, V> entrySet;


    /* ---------------- Public operations -------------- */

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

    /**
     * 构造器, 创建一个新的空map,可指定其初始化的数组的大小 . 而不需动态调增
     */
    public MyConcurrentHashMap(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 MyConcurrentHashMap(Map<? extends K, ? extends V> m) {
        this.sizeCtl = DEFAULT_CAPACITY;
        putAll(m);
    }

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

    /**
     * 构造器
     * @param initialCapacity  初始化容量
     * @param loadFactor       加载因子
     * @param concurrencyLevel 并发级别--default = 16
     */
    public MyConcurrentHashMap(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;
    }

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

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

4.initTable: 初始化数组

    /**
     * 使用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;
    }

5.addCount: 节点计数器

   /**
     * 从 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 ((as = counterCells) != null ||
                !U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) {
            CounterCell a;
            long v;
            int m;
            boolean uncontended = true;
            if (as == null || (m = as.length - 1) < 0 ||
                    (a = as[ThreadLocalRandom.getProbe() & m]) == null ||
                    !(uncontended =
                            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();
            }
        }
    }

6.putTreeval():插入树节点

       /**
         *红黑树结构中新增节点数据
         *
         * @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;
        }

7.balanceInsertion():平衡红黑树的结构

       /**
         * 插入后用于维持红黑树性质的修复操作，
         * @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);
                            }
                        }
                    }
                }
            }
        }

8.tableSizeFor(): 确保当前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;
    }

9. treeifyBin(): 链表转红黑树

  /**
     * 数组中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));
                    }
                }
            }
        }
    }

10.tryPresize: 数组扩容

   /**
     * 扩容
     */
    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);
            }
        }
    }

11. resizeStamp

   /**
     * 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));
    }

12.helpTransfer: 辅助扩容

   /**
     * 帮助执行扩容
     * 关于 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;
    }