Java ConcurrentHashMap 源代码分析

Java ConcurrentHashMap

jdk1.8

之前用到过这个，但是一直不清楚原理，今天抽空看了一下代码

但是由于我一直在使用java8，试了半天，暂时还没复现过put死循环的bug

查了一下，java8似乎修复了这个:不过还是可能导致数据丢失

https://cloud.tencent.com/developer/article/1120823

java8之前都是头插入，而java8却是靠新一位的掩码来把链表分成两个，没有改变相对顺序

果然还是代码理解的不透彻啊

Java 8的ConcurrentMap是真的不好理解

我们现在开始分析ConcurrentHashMap

跟HashMap类似

public class ConcurrentHashMap<K,V> extends AbstractMap<K,V>
    implements ConcurrentMap<K,V>, Serializable

先看一下java 8 中的ConcurrentHashMap的 一些定义常量

//定义了最大容量
private static final int MAXIMUM_CAPACITY = 1 << 30;
//定义了每个大小
private static final int DEFAULT_CAPACITY = 16;
static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
//最多支持多少个并发操作 这个是1.7之前的，1.8基本没用到过这个
private static final int DEFAULT_CONCURRENCY_LEVEL = 16;
//同hashmap
private static final float LOAD_FACTOR = 0.75f;
//树阈值
static final int TREEIFY_THRESHOLD = 8;
//红黑树退化链表的阈值
static final int UNTREEIFY_THRESHOLD = 6;
//数量到达这些的时候开始变成红黑树
static final int MIN_TREEIFY_CAPACITY = 64;

先来看一下构造方法

    public ConcurrentHashMap() {
    }
    public ConcurrentHashMap(int initialCapacity) {
        if (initialCapacity < 0)
            throw new IllegalArgumentException();
        //只是设置 sizeCtl 如果初始容量过大，那么设置为最大容量，否则设置大小为
        //
        int cap = ((initialCapacity >= (MAXIMUM_CAPACITY >>> 1)) ?
                   MAXIMUM_CAPACITY :
                   tableSizeFor(initialCapacity + (initialCapacity >>> 1) + 1));

        this.sizeCtl = cap;
    }
	//对齐到2的整数次幂 跟hashmap一样
	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;
    }
//初始容量，扩容因子，最多并发等级
    public ConcurrentHashMap(int initialCapacity,
                             float loadFactor, int concurrencyLevel) {
        if (!(loadFactor > 0.0f) || initialCapacity < 0 || concurrencyLevel <= 0)
            throw new IllegalArgumentException();
        //可见如果如果出事容量小于最多并发等级的话，会设置为为最多并发等级那么多的初始容量
        //不过这个构造方法应该是兼容以前的构造方法，concurrencyLevel在1.8没太大意义
        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;
    }

初始化大小是initialCapacity*1.5 + 1然后对齐到2的整数次幂跟HashMap一样

//看一下init
private final Node<K,V>[] initTable() {
        Node<K,V>[] tab; int sc;
    	//这个时候检查创建状态
        while ((tab = table) == null || tab.length == 0) {
            //没创建才能进来
            //sizeCtl<0说明有其他的线程抢先拿到了自旋锁 那么放弃执行
            if ((sc = sizeCtl) < 0)
                Thread.yield(); // lost initialization race; just spin
            //CAS尝试获取 如果 sizeCtl == sc 成功那么交换成-1
            //SIZECTL = U.objectFieldOffset (k.getDeclaredField("sizeCtl"));
            else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
                //获取到了
                try {
                    //这里相当于多线程单例模式两个if来判断
                    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;
                        //减去1/4相当于*0.75
                        sc = n - (n >>> 2);
                    }
                } finally {
                    sizeCtl = sc;
                }
                break;
            }
        }
        return tab;
    }

下面的函数经常用到相当于这样

int baseOffset = unsafe.arrayBaseOffset(array.getClass());

int indexScale = unsafe.arrayIndexScale(array.getClass());

baseOffset + i*indexScale

主要目的就是获取最新的volatile的数据

	//这个函数相当于tab获取i节点最新的对象数据
	//
	static final <K,V> Node<K,V> tabAt(Node<K,V>[] tab, int i) {
        // Class<?> ak = Node[].class;
        // ABASE = U.arrayBaseOffset(ak);  获取数组第一个元素的偏移地址
        // int scale = U.arrayIndexScale(ak);  获取数组中元素的增量地址
        // Integer.numberOfLeadingZeros 是获取前导0的数量
        // ASHIFT = 31 - Integer.numberOfLeadingZeros(scale);
        return (Node<K,V>)U.getObjectVolatile(tab, ((long)i << ASHIFT) + ABASE);
    }

    //cas 交换c,v
	static final <K,V> boolean casTabAt(Node<K,V>[] tab, int i,
                                        Node<K,V> c, Node<K,V> v) {
        return U.compareAndSwapObject(tab, ((long)i << ASHIFT) + ABASE, c, v);
    }

这里定义了Node的状态，通过node.hash来判断

    /*
     * 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

 /** Implementation for put and putIfAbsent */
    final V putVal(K key, V value, boolean onlyIfAbsent) {
        //ConcurrentHashMap 的key和value不能存放空
        //而HashMap中key，Value 都是null
        if (key == null || value == null) throw new NullPointerException();
        //跟HashMap一样，计算hashcode，然后高16位跟低16位按位异或
        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)
                //这里面通过CAS创建的
                tab = initTable();
            //先获取i 然后获取Node
            else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
                //i 这个地方不存在节点 那么尝试创建一个节点并cas
                //如果成功了就跳出循环了
                if (casTabAt(tab, i, null,
                             new Node<K,V>(hash, key, value, null)))
                    break;                   // no lock when adding to empty bin
            }
            //i这个位置不是null 判断是不是应该移动 但是估计这里hash改变过了
            // 在 transfer方法中
            // 这里面如果是正在扩容，那么这个线程过去帮忙扩容
            else if ((fh = f.hash) == MOVED)
                //扩容操作
                tab = helpTransfer(tab, f);
            else {
                //开始正式插入k,v
                V oldVal = null;
                //这里仅仅锁住桶
                synchronized (f) {
                    if (tabAt(tab, i) == f) {
                        //判断hash>=0 这里面hash >= 0 认为是链表，否则认为是红黑树
                        if (fh >= 0) {
                            //这里面判断一共多少个节点
                            binCount = 1;
                            for (Node<K,V> e = f;; ++binCount) {
                                K ek;
                                //一样，先判断hash然后用equals
                                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;
                                }
                            }
                        }
                        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;
                            }
                        }
                    }
                }
                //这里判断节点数量
                if (binCount != 0) {
                    //如果大于树的阈值，那就转化为红黑树
                    if (binCount >= TREEIFY_THRESHOLD)
                        treeifyBin(tab, i);
                    if (oldVal != null)
                        return oldVal;
                    break;
                }
            }
        }
        //判断大小，尝试扩容
        addCount(1L, binCount);
        return null;
    }

    /**
     * Replaces all linked nodes in bin at given index unless table is
     * too small, in which case resizes instead.
     */
    private final void treeifyBin(Node<K,V>[] tab, int index) {
        Node<K,V> b; int n, sc;
        if (tab != null) {
            //当tab小于MIN_TREEIFY_CAPACITY阈值的时候尝试resize
            //如果tab.length比较小，不会转化为红黑树，直接扩容
            if ((n = tab.length) < MIN_TREEIFY_CAPACITY)
                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;
                        //遍历这个桶的链表
                        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)
                                hd = p;//第一个元素赋值给hd
                            else
                                //把树节点赋值给上一个的下一个，就是连上了
                                tl.next = p;
                            tl = p;
                        }
                        //用连在一起的treenode创建一个红黑树
                        setTabAt(tab, index, new TreeBin<K,V>(hd));
                    }
                }
            }
        }
    }

/**
 * Tries to presize table to accommodate the given number of elements.
 *
 * @param size number of elements (doesn't need to be perfectly accurate)
 */
private final void tryPresize(int size) {
    //对齐
    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;
        //判断tab
        if (tab == null || (n = tab.length) == 0) {
            //当前容量和需要扩大到的容量取max
            n = (sc > c) ? sc : c;
            //CAS获取锁 然后初始化
            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;
                        //相当于*0.75
                        sc = n - (n >>> 2);
                    }
                } finally {
                    sizeCtl = sc;
                }
            }
        }
        //如果超过了最大容量就不要扩容了
        else if (c <= sc || n >= MAXIMUM_CAPACITY)
            break;
        //如果tab!=table说明已经迁移完了不用再迁移了
        else if (tab == table) {
			// RESIZE_STAMP_BITS = 16;
            // Integer.numberOfLeadingZeros(n) | (1 << (RESIZE_STAMP_BITS - 1)
			//这个函数大概意思就是把第16位置1，为了变成一个负数
            int rs = resizeStamp(n);
            if (sc < 0) {
                //sc < 0 相当于获取到锁
                Node<K,V>[] nt;
                //这里还是不太理解=================================================
                //我还没想出来为什么sc<0还会进来 所以下面是猜测
                //RESIZE_STAMP_SHIFT = 32 - RESIZE_STAMP_BITS;
                //所以RESIZE_STAMP_SHIFT也是16
                //这里是我还没有仔细判断 挖个坑
                //因为别的地方也有可能获取到锁导致sc<0
                //所以这里判断sc是不是真正自己的
                //这里sc右移 如果sc!=rs 应该是别的线程已经扩容完毕
                //如果上一个没执行完，那么
                // sc == (rs << RESIZE_STAMP_SHIFT) + 2
                // transfer中 sc的改变只能是每次 -1
                // nextTable == null 说明nextTable还没创建所以不执行
                // MAX_RESIZERS = (1 << (32 - RESIZE_STAMP_BITS)) - 1;
                // 这个判断是防止帮助的线程太多，导致sc变成正数 (个人猜测)
                if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
                    sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
                    transferIndex <= 0)
                    break;
                //多一个线程进入 + 1
                if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
                    //开始扩容
                    transfer(tab, nt);
            }
            //事实上先执行这个相当于先去获取锁
            //如果能获取到那么把sizeCtl设置为一个负数值 + 2 就是刚才计算的那个值
            //然后执行一个扩容操作
            else if (U.compareAndSwapInt(this, SIZECTL, sc,
                                         (rs << RESIZE_STAMP_SHIFT) + 2))
                transfer(tab, null);
        }
    }
}

上面的代码会多次调用 transfer方法

第一次是 transfer(tab,null)

从第二次开始 调用 transfer(tab,nt);

    /**
     * Moves and/or copies the nodes in each bin to new table. See
     * above for explanation.
     */
//开始并且将transfer tab的数据逐渐迁移到nextTab中
    private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
        //n为tab的旧长度
        int n = tab.length, stride;
        //这里在判断是不是多核心cpu
        //参考了一下别人的注释:
        /*
        	stride 在单核下直接等于 n，多核模式下为 (n>>>3)/NCPU，最小值是 16
			stride 可以理解为”步长“，有 n 个位置是需要进行迁移的，
			将这 n 个任务分为多个任务包，每个任务包有 stride 个任务
        */
        if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
            stride = MIN_TRANSFER_STRIDE; // subdivide range
        //nextTab为null那么先创建一个二倍大的tab
        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是ConcurrentHashMap中的属性
            nextTable = nextTab;
			// transferIndex 也是 ConcurrentHashMap 的属性，用于控制迁移的位置
            transferIndex = n;
        }
        //nextTab的长度
        int nextn = nextTab.length;
        //这里参考别人的注释
        // ForwardingNode 翻译过来就是正在被迁移的 Node
        // 这个构造方法会生成一个Node，key、value 和 next 都为 null，关键是 hash 为 MOVED
        // 后面我们会看到，原数组中位置 i 处的节点完成迁移工作后，
        // 就会将位置 i 处设置为这个 ForwardingNode，用来告诉其他线程该位置已经处理过了
        // 所以它其实相当于是一个标志。
        // 所以在putVal中才可以检查
        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;
            //这个循环没看懂 参考了别人的
            /*
            //	下面这个 while 真的是不好理解
            //	advance 为 true 表示可以进行下一个位置的迁移了
            //	简单理解结局：i 指向了 transferIndex，bound 指向了 transferIndex-stride
            */
            while (advance) {
                int nextIndex, nextBound;
                // 0
                if (--i >= bound || finishing)
                    advance = false;//设为false下次跳出
                /*
                // 将 transferIndex 值赋给 nextIndex
            	// 这里 transferIndex 一旦小于等于 0，说明原数组的所有位置都有相应的线程去处理了
                */
                else if ((nextIndex = transferIndex) <= 0) {
                    i = -1;
                    advance = false;
                }
                else if (U.compareAndSwapInt
                         (this, TRANSFERINDEX, nextIndex,
                          nextBound = (nextIndex > stride ?
                                       nextIndex - stride : 0))) {
                    //在这里领到一个任务
                    //这次的任务边界
                    //i是结束位置 bound是开始位置
                    bound = nextBound;
                    i = nextIndex - 1;
                    advance = false;
                }
            }
            //如果不在oldtab的长度范围内，该线程准备退出
            //说明领到的任务失效了
            if (i < 0 || i >= n || i + n >= nextn) {
                int sc;
                if (finishing) {
                    nextTable = null;
                    //在这里覆盖原来的
                    table = nextTab;
                    //长度的0.75
                    sizeCtl = (n << 1) - (n >>> 1);
                    return;
                }
                /*
                // 之前我们说过，sizeCtl 在迁移前会设置为 (rs << RESIZE_STAMP_SHIFT) + 2
                // 然后，每有一个线程参与迁移就会将 sizeCtl 加 1，
                // 这里使用 CAS 操作对 sizeCtl 进行减 1，代表做完了属于自己的任务
                // 进来的时候假如说 sc=sizeCtl = -21xxxxx174  rs<<16==-21xxx174 - 2
                // 然后CAS sizeCtl=-21xxxxx175 sc-2=-21xxxxx176
                */
                if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
                    //这个线程迁移完之后判断是不是完全执行完
                    if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)
                        return;
                    //在这里说明最后进入的线程都已经结束了
                    finishing = advance = true;
                    i = n; // recheck before commit
                }
            }
            //oldtab的i位置如果为null 那么把他设为 刚才创建的ForwardingNode
            else if ((f = tabAt(tab, i)) == null)
                advance = casTabAt(tab, i, null, fwd);
            //这个位置不是null 但是这个位置是一个ForwardingNode
            else if ((fh = f.hash) == MOVED)
                advance = true; // already processed
            else {
                //对这个桶加锁 然后开始把数据搬到新的tab
                synchronized (f) {
                    if (tabAt(tab, i) == f) {
                        Node<K,V> ln, hn;
                        //hash > 0 说明是链表
                        if (fh >= 0) {
                            //这里跟HashMap类似，就是分成两个链表
                            int runBit = fh & n;
                            Node<K,V> lastRun = f;
                            for (Node<K,V> p = f.next; p != null; p = p.next) {
                                int b = p.hash & n;
                                if (b != runBit) {
                                    runBit = b;
                                    lastRun = p;
                                }
                            }
                            if (runBit == 0) {
                                ln = lastRun;
                                hn = null;
                            }
                            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;
                                }
                            }
                            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;
                            // 将 ln 放置在新数组的位置 i
                            setTabAt(nextTab, i, ln);
                            // 将 hn 放置在新数组的位置 i+n
                            setTabAt(nextTab, i + n, hn);
                            // 将原数组该位置处设置为 fwd，代表该位置已经处理完毕，
                        	// 其他线程一旦看到该位置的 hash 值为 MOVED，就不会进行迁移了
                            setTabAt(tab, i, fwd);
                            // advance 设置为 true，代表该位置已经迁移完毕
                            advance = true;
                        }
                    }
                }
            }
        }
    }

相比之下，get就好多了 一个CAS锁都没有

    /**
     * Returns the value to which the specified key is mapped,
     * or {@code null} if this map contains no mapping for the key.
     *
     * <p>More formally, if this map contains a mapping from a key
     * {@code k} to a value {@code v} such that {@code key.equals(k)},
     * then this method returns {@code v}; otherwise it returns
     * {@code null}.  (There can be at most one such mapping.)
     *
     * @throws NullPointerException if the specified key is null
     */
    public V get(Object key) {
        Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
        //先去获取一下hashcode 跟hashmap一样，高16xor低16
        int h = spread(key.hashCode());
        //判断表是否创建，以及对应的位置有没有节点
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (e = tabAt(tab, (n - 1) & h)) != null) {
            //hashcode相等，判断是不是
            if ((eh = e.hash) == h) {
                //判断key的hashcode，判断key.equals
                if ((ek = e.key) == key || (ek != null && key.equals(ek)))
                    return e.val;
            }
            //eh < 0说明是个红黑树节点或者这个地方正在扩容
            else if (eh < 0)
                return (p = e.find(h, key)) != null ? p.val : null;
            //都不是这个地方应该是个链表，尝试遍历
            while ((e = e.next) != null) {
                if (e.hash == h &&
                    ((ek = e.key) == key || (ek != null && key.equals(ek))))
                    return e.val;
            }
        }
        return null;

注意这里，因为红黑树的节点是继承了Node，所以TreeNode是把这个方法覆盖了

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

总体感觉：

ConcurrentMap跟1.7不一样，1.7是使用segment分段锁，这种感觉就是每一个segment里面放一个(1.7)hashmap先通过key找到对应的segment然后再去hashmap里面找，put的时候对应的segment加锁

1.8完全就是每一个小桶里面可以存null treenode node，完全没有使用segment锁，put对应的表的时候，会synchronized对应的桶，然后尝试放进去，扩容的时候，也是使用乐观锁，如果可以扩容，那么把sizectl设置为负数，每次cas获取一个小任务，如果这个时候别的线程在put会检查，如果可以，别的线程也会进来帮你分担任务，不过涉及到大量的unsafe类的操作，流程比较容易理解，但是实现还是不好理解

关于为什么使用tabAt这几个函数:

https://www.cnblogs.com/lc-java/p/9301416.html

java中可以创建volatile数组，不过只是一个指向数组的引用，而不是整个数组，如果改变引用指向的数组，将会受到volatile的保护，但是如果多个线程同时改变数组的元素，volatile 标示符就不能起到之前的保护作用了。

这里面有图，很容易理解这几个Map的区别

<http://www.importnew.com/28263.html>

Unsafe类

https://www.jianshu.com/p/cda24891f9e4

注意事项

https://blog.csdn.net/lx1848/article/details/81256443