jdk源码解析三之JUC并发容器

本篇文章主要是对JUC包下,一些并发类的源码分析,如果想了解具体实例,请点击

并发容器

ConcurrentHashMap

 //使用了unSafe方法，通过直接操作内存的方式来保证并发处理的安全性，使用的是硬件的安全机制。
    /*
     * 用来返回节点数组的指定位置的节点的原子操作
     */
    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);
    }

    /*
     * cas原子操作，在指定位置设定值
     */
    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);
    }
    /*
     * 原子操作，在指定位置设定值
     */
    static final <K,V> void setTabAt(Node<K,V>[] tab, int i, Node<K,V> v) {
        U.putObjectVolatile(tab, ((long)i << ASHIFT) + ABASE, v);
    }

put

    public V put(K key, V value) {

        /*
         * onlyIfAbsent
         *  false:这个value一定会设置
         *  true:只有当这个key的value为空的时候才会设置
         */
        return putVal(key, value, false);
    }

    final V putVal(K key, V value, boolean onlyIfAbsent) {
        //不允许key/value为null,否则及时失败
        if (key == null || value == null) throw new NullPointerException();
        //获取key的hashCode
        int hash = spread(key.hashCode());
        //用来计算在这个节点总共有多少个元素，用来控制扩容或者转移为树
        int binCount = 0;
        for (Node<K,V>[] tab = table;;) {
            Node<K,V> f; int n, i, fh;
            //初始化tab
            if (tab == null || (n = tab.length) == 0)
                tab = initTable();
            else if (
                //通过哈希计算出一个表中的位置因为n是数组的长度，所以(n-1)&hash肯定不会出现数组越界
                    (f = tabAt(tab, i = (n - 1) & hash)) == null) {
                //如果这个位置没有元素的话，则通过cas的方式尝试添加，注意这个时候是没有加锁的
                if (casTabAt(tab, i, null,
                             new Node<K,V>(hash, key, value, null)))
                    break;                   // no lock when adding to empty bin
            }
            /*
             * 如果检测到某个节点的hash值是MOVED，则表示正在进行数组扩张的数据复制阶段，
             * 则当前线程也会参与去复制，通过允许多线程复制的功能，一次来减少数组的复制所带来的性能损失
             */
            else if ((fh = f.hash) == MOVED)
                tab = helpTransfer(tab, f);
            else {
                V oldVal = null;
                synchronized (f) {
                    //再次取出要存储的位置的元素，跟前面取出来的比较
                    if (tabAt(tab, i) == f) {
                        //取出来的元素的hash值大于0，当转换为树之后，hash值为-2
                        if (fh >= 0) {
                            binCount = 1;
                            for (Node<K,V> e = f;; ++binCount) {
                                K ek;
                                //查找到值,则覆盖
                                if (e.hash == hash &&
                                    ((ek = e.key) == key ||
                                     (ek != null && key.equals(ek)))) {
                                    oldVal = e.val;
                                    if (!onlyIfAbsent)
                                        e.val = value;
                                    break;
                                }
                                Node<K,V> pred = e;
                                //找到最后,没找到值的,则新建对象.
                                if ((e = e.next) == null) {
                                    //添加链表尾端
                                    pred.next = new Node<K,V>(hash, key,
                                                              value, null);
                                    break;
                                }
                            }
                        }
                        //对红黑树的处理
                        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) {
                    //链表节点其中个数达到8,则扩张数组或转成树
                    if (binCount >= TREEIFY_THRESHOLD)
                        treeifyBin(tab, i);
                    if (oldVal != null)
                        return oldVal;
                    break;
                }
            }
        }
        //计数
        addCount(1L, binCount);
        return null;
    }

初始化

   private final Node<K,V>[] initTable() {
        Node<K,V>[] tab; int sc;
        while ((tab = table) == null || tab.length == 0) {
            //sizeCtl初始值为0，当小于0的时候表示在别的线程在初始化表或扩展表
            //则暂停当前正在执行的线程对象，并执行其他线程。
            if ((sc = sizeCtl) < 0)
                Thread.yield(); // lost initialization race; just spin
            else if (
                  /*
                   SIZECTL:当前内存偏移量,
                    sc:期望值
                    -1:表示要替换的值
                */
                    U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
                try {
                    if ((tab = table) == null || tab.length == 0) {
                        //指定了大小的时候就创建指定大小的Node数组，否则创建指定大小(16)的Node数组
                        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长度为数组长度的3/4
                    sizeCtl = sc;
                }
                break;
            }
        }
        return tab;
    }

扩容

    /**
     * Replaces all linked nodes in bin at given index unless table is
     * too small, in which case resizes instead.
     * 数组长度<64,则扩容一倍
     * 否则转成树
     */
    private final void treeifyBin(Node<K,V>[] tab, int index) {
        Node<K,V> b; int n, sc;
        if (tab != null) {
            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);
                            //把Node组成的链表，转化为TreeNode的链表，头结点依然放在相同的位置
                            if ((p.prev = tl) == null)
                                hd = p;
                            else
                                tl.next = p;
                            tl = p;
                        }
                        //把TreeNode的链表放入容器TreeBin中,内部将单节点树转换成红黑树
                        setTabAt(tab, index, new TreeBin<K,V>(hd));
                    }
                }
            }
        }
    }

 private final void tryPresize(int size) {
        //扩容大小>=最大的一半,直接设置成最大容量
        int c = (size >= (MAXIMUM_CAPACITY >>> 1)) ? MAXIMUM_CAPACITY :
                //返回大于输入参数且最近的2的整数次幂的数
            tableSizeFor(size + (size >>> 1) + 1);
        int sc;
        while ((sc = sizeCtl) >= 0) {
            Node<K,V>[] tab = table; int n;
            //如果数组还没有初始化
            //putAll的时候,会执行这儿
            if (tab == null || (n = tab.length) == 0) {
                n = (sc > c) ? sc : c;
                //SIZECTL设置-1，表示正在初始化
                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=3/4*n
                            sc = n - (n >>> 2);
                        }
                    } finally {
                        sizeCtl = sc;
                    }
                }
            }
            //扩容后的大小<=sizeCtl或者当前数组长度>容量上限,则退出
            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;
                    //transfer线程数+1,当前线程将加入对transfer的处理
                    //transfer的时候,sc表示在transfer工作的线程数
                    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);
            }
        }
    }


    private static final int tableSizeFor(int c) {

        /*
        　　让cap-1再赋值给n的目的是另找到的目标值大于或等于原值。例如二进制1000，十进制数值为8。
        如果不对它减1而直接操作，将得到答案10000，即16。显然不是结果。
        减1后二进制为111，再进行操作则会得到原来的数值1000，即8。
         */
        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;
    }

 private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
        int n = tab.length, stride;
        //MIN_TRANSFER_STRIDE=16.控制线程数
        //每个CPU最少处理16个长度的数组元素,也就是说，如果一个数组的长度只有16，那只有一个线程会对其进行扩容的复制移动操作
        if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
            stride = MIN_TRANSFER_STRIDE; // subdivide range
        //只有第一个线程进此方法的时候,才会初始化数组.
        if (nextTab == null) {            // initiating
            try {
                @SuppressWarnings("unchecked")
                        //扩容一倍数组容量
                Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n << 1];
                nextTab = nt;
            } catch (Throwable ex) {      // try to cope with OOME
                sizeCtl = Integer.MAX_VALUE;
                return;
            }
            //这里标记数组初始化完成,
            nextTable = nextTab;
            transferIndex = n;
        }
        int nextn = nextTab.length;
        /*
         * 创建一个fwd节点，这个是用来控制并发的，当一个节点为空或已经被转移之后，就设置为fwd节点
         * 这是一个空的标志节点
         */
        ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);
        //是否继续向前查找的标志位
        boolean advance = true;
        //在完成之前重新在扫描一遍数组，看看有没完成的没
        boolean finishing = false; // to ensure sweep before committing nextTab
        for (int i = 0, bound = 0;;) {
            Node<K,V> f; int fh;
            while (advance) {
                int nextIndex, nextBound;
                if (--i >= bound || finishing)
                    advance = false;
                else if ((nextIndex = transferIndex) <= 0) {
                    i = -1;
                    advance = false;
                }
                else if (U.compareAndSwapInt
                         (this, TRANSFERINDEX, nextIndex,
                          nextBound = (nextIndex > stride ?
                                       nextIndex - stride : 0))) {
                    //如果一个数组的长度只有16，只有一个线程会对其进行扩容的复制移动操作
                    bound = nextBound;
                    i = nextIndex - 1;
                    advance = false;
                }
            }
            if (i < 0 || i >= n || i + n >= nextn) {
                int sc;
                //已经完成转移
                if (finishing) {
                    nextTable = null;
                     //这里完成nextTab=>table转换
                    table = nextTab;
                    //为扩容后的0.75
                    sizeCtl = (n << 1) - (n >>> 1);
                    return;
                }
                //正在工作的线程数-1,并返回
                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
                }
            }
            else if ((f = tabAt(tab, i)) == null)
                //数组中把null的元素设置为ForwardingNode节点(hash值为MOVED)
                advance = casTabAt(tab, i, null, fwd);
            else if ((fh = f.hash) == MOVED)
                //表示已有线程正在处理
                advance = true; // already processed
            else {
                synchronized (f) {
                    //双重检查加锁
                    if (tabAt(tab, i) == f) {
                        Node<K,V> ln, hn;
                        //>=0说明是node节点
                        if (fh >= 0) {
                            //为0则表示放在扩容后数组当前索引下,否则放在n+之前位置索引下
                            int runBit = fh & n;
                            Node<K,V> lastRun = f;
                            /*
                            循环结束之后,runBit就是最后不变的hash&n的值
                            也就是说由lastRun节点后的hash&n的值一样,这样就可以直接保存,而不需要处理后面的节点
                             */
                            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;
                            }
                            //分别逆序存入ln或hn链表中
                            for (Node<K,V> p = f; p != lastRun; p = p.next) {
                                int ph = p.hash; K pk = p.key; V pv = p.val;
                                if ((ph & n) == 0)
                                    ln = new Node<K,V>(ph, pk, pv, ln);
                                else
                                    hn = new Node<K,V>(ph, pk, pv, hn);
                            }
                            //存入之前的位置
                            setTabAt(nextTab, i, ln);
                            //存入改变后的位置
                            setTabAt(nextTab, i + n, hn);
                            //设置fwd,这样其他线程执行的时候,会跳过去.
                            setTabAt(tab, i, fwd);
                            advance = true;
                        }
                        else if (f instanceof TreeBin) {
                            TreeBin<K,V> t = (TreeBin<K,V>)f;
                            TreeNode<K,V> lo = null, loTail = null;
                            TreeNode<K,V> hi = null, hiTail = null;
                            int lc = 0, hc = 0;
                            for (Node<K,V> e = t.first; e != null; e = e.next) {
                                int h = e.hash;
                                TreeNode<K,V> p = new TreeNode<K,V>
                                    (h, e.key, e.val, null, null);
                                if ((h & n) == 0) {
                                    if ((p.prev = loTail) == null)
                                        lo = p;
                                    else
                                        loTail.next = p;
                                    loTail = p;
                                    ++lc;
                                }
                                else {
                                    if ((p.prev = hiTail) == null)
                                        hi = p;
                                    else
                                        hiTail.next = p;
                                    hiTail = p;
                                    ++hc;
                                }
                            }
                            /*
                             * 在复制完树节点之后，判断该节点处构成的树还有几个节点，
                             * 如果≤6个的话，就转为一个链表
                             */
                            ln = (lc <= UNTREEIFY_THRESHOLD) ? untreeify(lo) :
                                (hc != 0) ? new TreeBin<K,V>(lo) : t;
                            hn = (hc <= UNTREEIFY_THRESHOLD) ? untreeify(hi) :
                                (lc != 0) ? new TreeBin<K,V>(hi) : t;
                            setTabAt(nextTab, i, ln);
                            setTabAt(nextTab, i + n, hn);
                            setTabAt(tab, i, fwd);
                            advance = true;
                        }
                    }
                }
            }
        }
    }


    final Node<K,V>[] helpTransfer(Node<K,V>[] tab, Node<K,V> f) {
        Node<K,V>[] nextTab; int sc;
        if (tab != null && (f instanceof ForwardingNode) &&
            (nextTab = ((ForwardingNode<K,V>)f).nextTable) != null) {
            int rs = resizeStamp(tab.length);
            while (nextTab == nextTable && table == tab &&
                   (sc = sizeCtl) < 0) {
                if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
                    sc == rs + MAX_RESIZERS || transferIndex <= 0)
                    break;
                //线程数+1,帮助一起转换
                if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1)) {
                    transfer(tab, nextTab);
                    break;
                }
            }
            return nextTab;
        }
        return table;
    }

get

    public V get(Object key) {
        Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
        int h = spread(key.hashCode());
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (e = tabAt(tab, (n - 1) & h)) != null) {
            //如果first匹配key-value,则直接返回
            if ((eh = e.hash) == h) {
                if ((ek = e.key) == key || (ek != null && key.equals(ek)))
                    return e.val;
            }
            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;
    }

replace#remove

    public V remove(Object key) {
        return replaceNode(key, null, null);
    }
 
    /**
     * {@inheritDoc}
     *
     * @throws NullPointerException if any of the arguments are null
     * key映射有值,值为oldValue,则更新
     */
    public boolean replace(K key, V oldValue, V newValue) {
        if (key == null || oldValue == null || newValue == null)
            throw new NullPointerException();
        return replaceNode(key, newValue, oldValue) != null;
    }


    final V replaceNode(Object key, V value, Object cv) {
        int hash = spread(key.hashCode());
        for (Node<K,V>[] tab = table;;) {
            Node<K,V> f; int n, i, fh;
            //空判断
            if (tab == null || (n = tab.length) == 0 ||
                (f = tabAt(tab, i = (n - 1) & hash)) == null)
                break;
            //正在扩容,则加入扩容队伍
            else if ((fh = f.hash) == MOVED)
                tab = helpTransfer(tab, f);
            else {
                V oldVal = null;
                boolean validated = false;
                synchronized (f) {
                    //双重检查加锁,DCL
                    if (tabAt(tab, i) == f) {
                        //对链表的处理
                        if (fh >= 0) {
                            validated = true;
                            for (Node<K,V> e = f, pred = null;;) {
                                K ek;
                                //匹配key
                                if (e.hash == hash &&
                                    ((ek = e.key) == key ||
                                     (ek != null && key.equals(ek)))) {
                                    V ev = e.val;
                                    //匹配value
                                    if (cv == null || cv == ev ||
                                        (ev != null && cv.equals(ev))) {
                                        oldVal = ev;
                                        //修改
                                        if (value != null)
                                            e.val = value;
                                        //value=null,说明执行删除操作
                                        else if (pred != null)
                                            pred.next = e.next;
                                        //当匹配的值是first节点的处理
                                        else
                                            setTabAt(tab, i, e.next);
                                    }
                                    break;
                                }
                                //临时保存上一个节点,便于执行删除节点操作
                                pred = e;
                                //执行最后一个节点,则退出
                                if ((e = e.next) == null)
                                    break;
                            }
                        }
                        //红黑树的处理
                        else if (f instanceof TreeBin) {
                            validated = true;
                            TreeBin<K,V> t = (TreeBin<K,V>)f;
                            TreeNode<K,V> r, p;
                            if ((r = t.root) != null &&
                                (p = r.findTreeNode(hash, key, null)) != null) {
                                V pv = p.val;
                                if (cv == null || cv == pv ||
                                    (pv != null && cv.equals(pv))) {
                                    oldVal = pv;
                                    if (value != null)
                                        p.val = value;
                                    else if (t.removeTreeNode(p))
                                        setTabAt(tab, i, untreeify(t.first));
                                }
                            }
                        }
                    }
                }
                if (validated) {
                    if (oldVal != null) {
                        if (value == null)
                            //记数-1
                            addCount(-1L, -1);
                        return oldVal;
                    }
                    break;
                }
            }
        }
        return null;
    }

总结:

什么时候扩容?

1. 单节点容量>=8且容量<64,则扩容一倍
2. 当数组中元素达到了sizeCtl的数量的时候，则会调用transfer方法来进行扩容

没有实现对map进行加锁来执行独占访问,因为采用了分段锁,所以无法使用客户端加锁来创建新的原子操作,如若没有则添加之内操作.

JDK1.8放弃分段锁
段Segment继承了重入锁ReentrantLock，有了锁的功能，每个锁控制的是一段，当每个Segment越来越大时，锁的粒度就变得有些大了。
分段锁的优势在于保证在操作不同段 map 的时候可以并发执行，操作同段 map 的时候，进行锁的竞争和等待。这相对于直接对整个map同步synchronized是有优势的。
缺点在于分成很多段时会比较浪费内存空间(不连续，碎片化); 操作map时竞争同一个分段锁的概率非常小时，分段锁反而会造成更新等操作的长时间等待; 当某个段很大时，分段锁的性能会下降。

jdk1.8的map实现
和hashmap一样,jdk 1.8中ConcurrentHashmap采用的底层数据结构为数组+链表+红黑树的形式。数组可以扩容，链表可以转化为红黑树。

为什么不用ReentrantLock而用synchronized ?
减少内存开销:如果使用ReentrantLock则需要节点继承AQS来获得同步支持，增加内存开销，而1.8中只有头节点需要进行同步。
内部优化:synchronized则是JVM直接支持的，JVM能够在运行时作出相应的优化措施：锁粗化、锁消除、锁自旋等等。

多个线程又是如何同步处理的呢？

1. 同步处理主要是通过Synchronized和unsafe两种方式来完成的。
2. 在取得sizeCtl、某个位置的Node的时候，使用的都是unsafe的方法，来达到并发安全的目的
   当需要在某个位置设置节点的时候，则会通过Synchronized的同步机制来锁定该位置的节点。
3. 在数组扩容的时候，则通过处理的步长和fwd节点来达到并发安全的目的，通过设置hash值为MOVED
4. 当把某个位置的节点复制到扩张后的table的时候，也通过Synchronized的同步机制来保证现程安全

CopyOnWriteArrayList

写入时复制,只要正确发布一个事实不可变对象,在访问该对象时就不再需要进一步同步,在每次修改时,都会创建并重新发布一个新的容器副本,从而实现可变性.
使用场景:迭代>修改,事件通知系统(注册和注销事件监听器操作少于接收事件通知的操作)

   //构造时,初始化容量为0的Object数组
    public CopyOnWriteArrayList() {
        setArray(new Object[0]);
    }

add

    public boolean add(E e) {
        final ReentrantLock lock = this.lock;
        //加锁
        lock.lock();
        try {
            Object[] elements = getArray();
            int len = elements.length;
            //创建数组副本,容量+1
            Object[] newElements = Arrays.copyOf(elements, len + 1);
            newElements[len] = e;
            //更新旧的数组
            setArray(newElements);
            return true;
        } finally {
            //解锁
            lock.unlock();
        }
    }

remove

    public E remove(int index) {
        final ReentrantLock lock = this.lock;
        //加锁
        lock.lock();
        try {
            //获取数组以及当前值
            Object[] elements = getArray();
            int len = elements.length;
            E oldValue = get(elements, index);
            
            int numMoved = len - index - 1;
            //最后一个数组索引,则直接copy
            if (numMoved == 0)
                setArray(Arrays.copyOf(elements, len - 1));
            else {
                //copy2次
                Object[] newElements = new Object[len - 1];
                System.arraycopy(elements, 0, newElements, 0, index);
                System.arraycopy(elements, index + 1, newElements, index,
                                 numMoved);
                setArray(newElements);
            }
            return oldValue;
        } finally {
            //解锁
            lock.unlock();
        }
    }

get

   public E get(int index) {
        return get(getArray(), index);
    }
    private E get(Object[] a, int index) {
        return (E) a[index];
    }

set

public E set(int index, E element) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            Object[] elements = getArray();
            E oldValue = get(elements, index);

            if (oldValue != element) {
                int len = elements.length;
                //副本修改
                Object[] newElements = Arrays.copyOf(elements, len);
                newElements[index] = element;
                //副本设置为当前数组
                setArray(newElements);
            } else {
                // Not quite a no-op; ensures volatile write semantics
                 //保证最终一致性
                setArray(elements);
            }
            return oldValue;
        } finally {
            lock.unlock();
        }
    }

总结

应用场景:读多写少
如:黑名单,监听器

读上没加锁,所以支持大量并发,但涉及修改的时候,有2个数组副本,当数组过大,则造成多余的内存消耗.

CopyOnWrite容器只能保证数据的最终一致性，不能保证数据的实时一致性。之所以只能保证最终一致,是因为每次涉及到修改都会copy一个副本然后回写,最终的结果是一致的,但是在copy途中如果有读操作,那么就会造成数据不一致问题.

LinkedBlockingQueue

一个基于链表的阻塞队列。此队列按 FIFO（先进先出）排序元素

   public LinkedBlockingQueue() {
        //默认最大容量
        this(Integer.MAX_VALUE);
    }

    public LinkedBlockingQueue(int capacity) {
        if (capacity <= 0) throw new IllegalArgumentException();
        this.capacity = capacity;
        //维护双端队列
        last = head = new Node<E>(null);
    }

put

//put将指定元素插入此队列尾部，将等待可用的空间
    public void put(E e) throws InterruptedException {
        if (e == null) throw new NullPointerException();
        // Note: convention in all put/take/etc is to preset local var
        // holding count negative to indicate failure unless set.
        int c = -1;
        //创建新节点
        Node<E> node = new Node<E>(e);
        //获取put锁
        final ReentrantLock putLock = this.putLock;
        final AtomicInteger count = this.count;
        //如果当前线程未被中断，则获取锁。
        putLock.lockInterruptibly();
        try {
            //达到上限容量,则一直等待
            while (count.get() == capacity) {
                notFull.await();
            }
            //设置值
            enqueue(node);
            c = count.getAndIncrement();
            if (c + 1 < capacity)
                //列是否有可用空间，如果有则唤醒一个等待线程
                notFull.signal();
        } finally {
            //释放锁
            putLock.unlock();
        }
        // 如果队列中有一条数据，唤醒消费线程进行消费
        if (c == 0)
            signalNotEmpty();
    }

offer

    public boolean offer(E e) {
        if (e == null) throw new NullPointerException();
        //等于最大容量,则返回,而不阻塞
        final AtomicInteger count = this.count;
        if (count.get() == capacity)
            return false;

        int c = -1;
        Node<E> node = new Node<E>(e);
        final ReentrantLock putLock = this.putLock;
        //因为不阻塞,所以直接获取锁
        putLock.lock();
        try {
            //再次检查容量大小,然后直接添加,随后唤醒一个等待线程
            if (count.get() < capacity) {
                enqueue(node);
                c = count.getAndIncrement();
                if (c + 1 < capacity)
                    notFull.signal();
            }
        } finally {
            putLock.unlock();
        }
        // 如果队列中有一条数据，唤醒消费线程进行消费
        if (c == 0)
            signalNotEmpty();
        return c >= 0;
    }

阻塞时间的offer

 public boolean offer(E e, long timeout, TimeUnit unit)
        throws InterruptedException {

        if (e == null) throw new NullPointerException();
        long nanos = unit.toNanos(timeout);
        int c = -1;
        final ReentrantLock putLock = this.putLock;
        final AtomicInteger count = this.count;
        //获取中断锁
        putLock.lockInterruptibly();
        try {
            //等于最大容量,则一直循环
            while (count.get() == capacity) {
                //超过超时时间则返回
                if (nanos <= 0)
                    return false;
                //当前线程在接到信号、被中断或到达指定等待时间之前一直处于等待状态。
                nanos = notFull.awaitNanos(nanos);
            }
            enqueue(new Node<E>(e));
            c = count.getAndIncrement();
            //通知信号
            if (c + 1 < capacity)
                notFull.signal();
        } finally {
            putLock.unlock();
        }
        // 如果队列中有一条数据，唤醒消费线程进行消费
        if (c == 0)
            signalNotEmpty();
        return true;
    }

take

//获取并移除此队列的头部，在元素变得可用之前一直等待
 public E take() throws InterruptedException {
        E x;
        int c = -1;
        final AtomicInteger count = this.count;
        final ReentrantLock takeLock = this.takeLock;
        //中断点
        takeLock.lockInterruptibly();
        try {
            //队列为空,阻塞等待
            while (count.get() == 0) {
                notEmpty.await();
            }
            //获取值
            x = dequeue();
            c = count.getAndDecrement();
            // 队列中还有元素，唤醒下一个消费线程进行消费
            if (c > 1)
                notEmpty.signal();
        } finally {
            takeLock.unlock();
        }
        // 之前队列是满的，则唤醒生产线程进行添加元素
        if (c == capacity)
            signalNotFull();
        return x;
    }

 private E dequeue() {
        // assert takeLock.isHeldByCurrentThread();
        // assert head.item == null;
         //head默认root的value是null
        Node<E> h = head;
        Node<E> first = h.next;
        // head节点原来指向的节点的next指向自己，等待下次gc回收
        h.next = h; // help GC
        // head节点指向下一个节点
        head = first;
        //获取新的head的value
        E x = first.item;
        //新的head设置null
        first.item = null;
        return x;
    }

poll

    public E poll() {
        final AtomicInteger count = this.count;
        //容量为0,直接返回
        if (count.get() == 0)
            return null;
        E x = null;
        int c = -1;
        final ReentrantLock takeLock = this.takeLock;
        takeLock.lock();
        try {
            if (count.get() > 0) {
                x = dequeue();
                c = count.getAndDecrement();
                if (c > 1)
                    notEmpty.signal();
            }
        } finally {
            takeLock.unlock();
        }
        if (c == capacity)
            signalNotFull();
        return x;
    }

peek

    public E peek() {
        if (count.get() == 0)
            return null;
        final ReentrantLock takeLock = this.takeLock;
        takeLock.lock();
        try {
            Node<E> first = head.next;
            if (first == null)
                return null;
            else
                return first.item;
        } finally {
            takeLock.unlock();
        }
    }

remove

    public boolean remove(Object o) {
        //为null,直接返回
        if (o == null) return false;
        //put和take锁,就暂时不能新增或修改
        fullyLock();
        try {
            for (Node<E> trail = head, p = trail.next;
                 p != null;
                 trail = p, p = p.next) {
                //匹配到值,则删除
                if (o.equals(p.item)) {
                    unlink(p, trail);
                    return true;
                }
            }
            return false;
        } finally {
            //释放2个锁
            fullyUnlock();
        }
    }

    void unlink(Node<E> p, Node<E> trail) {
        // assert isFullyLocked();
        // p.next is not changed, to allow iterators that are
        // traversing p to maintain their weak-consistency guarantee.
        p.item = null;
          //在迭代的时候,如果p.next为null,则会造成异常.所以这里没设置null
        trail.next = p.next;
        if (last == p)
            last = trail;
        // 如果删除之前元素是满的，删除之后就有空间了，唤醒生产线程放入元素
        if (count.getAndDecrement() == capacity)
            notFull.signal();
    }

迭代器

当执行迭代器的nextNode的时候,如果同时发现有执行take操作,因为当前head.next指向了自己,

        private Node<E> nextNode(Node<E> p) {
            for (;;) {
                Node<E> s = p.next;
                //take时,head.next=head,则直接返回当前head的下一个节点
                if (s == p)
                    return head.next;
                if (s == null || s.item != null)
                    return s;
                p = s;
            }
        }

总结

底层阻塞队列FIFO.内部由两个ReentrantLock来实现出入队列的线程安全，由各自的Condition对象的await和signal来实现等待和唤醒功能。
默认容量无界,且底层链表,所以执行插入和删除效率比较高.且2把锁维护新增删除,所以并发有所提高.

ArrayBlockingQueue

    public ArrayBlockingQueue(int capacity, boolean fair) {
        if (capacity <= 0)
            throw new IllegalArgumentException();
        this.items = new Object[capacity];
        //一把锁管理
        lock = new ReentrantLock(fair);
        notEmpty = lock.newCondition();
        notFull =  lock.newCondition();
    }

put

    public void put(E e) throws InterruptedException {
        //value不允许为null
        checkNotNull(e);
        final ReentrantLock lock = this.lock;
        //中断锁
        lock.lockInterruptibly();
        try {
            //当前count超过生产的容量上限,则等待
            while (count == items.length)
                notFull.await();
            enqueue(e);
        } finally {
            //释放锁
            lock.unlock();
        }
    }

private void enqueue(E x) {
        // assert lock.getHoldCount() == 1;
        // assert items[putIndex] == null;
        final Object[] items = this.items;
        items[putIndex] = x;
        //当前个数超过下标,则回滚为0下标
        if (++putIndex == items.length)
            putIndex = 0;
        //当前可进行消息个数+1
        count++;
        //唤醒消费线程进行消费
        notEmpty.signal();
    }
    

offer

    public boolean offer(E e) {
        checkNotNull(e);
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            //当前消息个数超过上限,则直接返回
            if (count == items.length)
                return false;
            else {
                enqueue(e);
                return true;
            }
        } finally {
            lock.unlock();
        }
    }

take

    public E take() throws InterruptedException {
        final ReentrantLock lock = this.lock;
        lock.lockInterruptibly();
        try {
            //当前没有消息,则等待
            while (count == 0)
                notEmpty.await();
            //消费消息
            return dequeue();
        } finally {
            lock.unlock();
        }
    }

    private E dequeue() {
        // assert lock.getHoldCount() == 1;
        // assert items[takeIndex] != null;
        final Object[] items = this.items;
        @SuppressWarnings("unchecked")
                //获取消息
        E x = (E) items[takeIndex];
        //清空消息
        items[takeIndex] = null;
        //当前消费的索引为数组长度,则从0开始消费消息
        if (++takeIndex == items.length)
            takeIndex = 0;
        count--;
        //迭代器冲突处理
        if (itrs != null)
            itrs.elementDequeued();
        //唤醒生产线程,生产消息
        notFull.signal();
        return x;
    }

        void elementDequeued() {
            // assert lock.getHoldCount() == 1;
            //消费个数为0，则清空迭代器值
            if (count == 0)
                queueIsEmpty();
            else if (takeIndex == 0)
                //消费的索引回滚为0处理
                takeIndexWrapped();
        }

remove

public boolean remove(Object o) {
        if (o == null) return false;
        final Object[] items = this.items;
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            if (count > 0) {
                final int putIndex = this.putIndex;
                int i = takeIndex;
                //遍历takeIndex ~ putIndex之间的数据,如果涉及到边界问题,则从0开始查找
                do {
                    //匹配则删除
                    if (o.equals(items[i])) {
                        removeAt(i);
                        return true;
                    }
                    //边界检测.
                    if (++i == items.length)
                        i = 0;
                } while (i != putIndex);
            }
            return false;
        } finally {
            lock.unlock();
        }
    }

 void removeAt(final int removeIndex) {
        // assert lock.getHoldCount() == 1;
        // assert items[removeIndex] != null;
        // assert removeIndex >= 0 && removeIndex < items.length;
        final Object[] items = this.items;
        //如果删除的消息和目前正take索引相同
        if (removeIndex == takeIndex) {
            // removing front item; just advance
            //清空当前take消息
            items[takeIndex] = null;
            //takeIndex偏移到下一个
            if (++takeIndex == items.length)
                takeIndex = 0;
            count--;
            //迭代器冲突处理
            if (itrs != null)
                itrs.elementDequeued();
        } else {
            // an "interior" remove

            // slide over all others up through putIndex.
            final int putIndex = this.putIndex;
            for (int i = removeIndex;;) {
                int next = i + 1;
                //达到数组上线,索引设为0,开始遍历
                if (next == items.length)
                    next = 0;
                //未到边界,则偏移到下一个数组值
                if (next != putIndex) {
                    items[i] = items[next];
                    i = next;
                } else {
                    //到了边界,设置当前items[putIndex]值为null,且更新putIndex
                    items[i] = null;
                    this.putIndex = i;
                    break;
                }
            }
            //当前消息个数-1
            count--;
            //迭代器冲突处理
            if (itrs != null)
                itrs.removedAt(removeIndex);
        }
        notFull.signal();
    }

总结

有界阻塞队列。此队列按 FIFO（先进先出）原则对元素进行排序。
初始化必须设置容量,value不允许为空
全局一个锁处理,相对并发比较低.
因为底层数组,所以修改查询快.

ThreadLocal

set

    public void set(T value) {
        //当前线程的.ThreadLocalMap绑定了当前ThreadLocal对象和value
        //获取当前线程
        Thread t = Thread.currentThread();
        //获取与当前线程绑定的map,这里主线程的map应该是jni初始化的
        ThreadLocalMap map = getMap(t);
        if (map != null)
            //将当前ThreadLocal与value绑定
            map.set(this, value);
        else
            //创建map
            createMap(t, value);
    }

初始化ThreadLocalMap

void createMap(Thread t, T firstValue) {
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }
  ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
            //初始化一个16容量数组
            table = new Entry[INITIAL_CAPACITY];
            //根据hash算出索引
            int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
            //Entry继承WeakReference
            //也就是说当一个对象仅仅被weak reference指向,
            // 而没有任何其他strong reference指向的时候, 如果GC运行, 那么这个对象就会被回收.
            table[i] = new Entry(firstKey, firstValue);
            //初始化容量值大小
            size = 1;
            //设置扩充容量值,容量*2/3
            setThreshold(INITIAL_CAPACITY);
        }

   static class Entry extends WeakReference<ThreadLocal<?>> {
            /** The value associated with this ThreadLocal. */
            Object value;

            Entry(ThreadLocal<?> k, Object v) {
                super(k);
                value = v;
            }
        }

set赋值

     private void set(ThreadLocal<?> key, Object value) {

            // We don't use a fast path as with get() because it is at
            // least as common to use set() to create new entries as
            // it is to replace existing ones, in which case, a fast
            // path would fail more often than not.

            Entry[] tab = table;
            int len = tab.length;
            int i = key.threadLocalHashCode & (len-1);

            /*
            遍历Entry
                如果找到了则赋值返回
                找到了回收的节点,则重新使用
             */
            for (Entry e = tab[i];
                 e != null;
                 e = tab[i = nextIndex(i, len)]) {
                ThreadLocal<?> k = e.get();

                //当前ThreadLocal与k一致,则赋值,并返回
                if (k == key) {
                    e.value = value;
                    return;
                }

                //说明被回收,则重新使用
                if (k == null) {
                    replaceStaleEntry(key, value, i);
                    return;
                }
            }

            //执行到这里,说明key不存在Entry中,被回收了
            //tab[i]此时为空,则赋值
            tab[i] = new Entry(key, value);
            int sz = ++size;
            //清空失效对象
            if (!cleanSomeSlots(i, sz) && sz >= threshold)
                //扩容
                rehash();
        }

重新使用失效节点

private void replaceStaleEntry(ThreadLocal<?> key, Object value,
                                       int staleSlot) {
            Entry[] tab = table;
            int len = tab.length;
            Entry e;

            // Back up to check for prior stale entry in current run.
            // We clean out whole runs at a time to avoid continual
            // incremental rehashing due to garbage collector freeing
            // up refs in bunches (i.e., whenever the collector runs).
            //记录失效节点索引
            int slotToExpunge = staleSlot;
            //根据传入无效的索引向前遍历,找到一段连续的无效的索引
            for (int i = prevIndex(staleSlot, len);
                 (e = tab[i]) != null;
                 i = prevIndex(i, len))
                if (e.get() == null)
                    slotToExpunge = i;
            //slotToExpunge此时只有2种状态
            //slotToExpunge=staleSlot,说明没有找到前驱节点有无效的
            //slotToExpunge!=staleSlot,说明靠近tab[i]=null的后驱节点有无效节点

            // Find either the key or trailing null slot of run, whichever
            // occurs first
            //遍历后驱节点
            for (int i = nextIndex(staleSlot, len);
                 (e = tab[i]) != null;
                 i = nextIndex(i, len)) {
                ThreadLocal<?> k = e.get();

                // If we find key, then we need to swap it
                // with the stale entry to maintain hash table order.
                // The newly stale slot, or any other stale slot
                // encountered above it, can then be sent to expungeStaleEntry
                // to remove or rehash all of the other entries in run.
                //找到了key,则与无效索引互换位置,也就是当前无效索引对应的是存储的key-value
                if (k == key) {
                    e.value = value;

                    tab[i] = tab[staleSlot];
                    tab[staleSlot] = e;

                    // Start expunge at preceding stale entry if it exists
                    //如果向前没有找到无效索引,则将slotToExpunge设置为i
                    if (slotToExpunge == staleSlot)
                        slotToExpunge = i;
                    //清空后续无效节点
                    cleanSomeSlots(
                            //删除无效节点,且返回下一个无效节点
                            expungeStaleEntry(slotToExpunge), len);
                    return;
                }

                // If we didn't find stale entry on backward scan, the
                // first stale entry seen while scanning for key is the
                // first still present in the run.
                //如果k为null说明被回收,且如果没有找到上一个无效索引,则更改slotToExpunge为i
                if (k == null && slotToExpunge == staleSlot)
                    slotToExpunge = i;
            }

            // If key not found, put new entry in stale slot
            //没有找到key,在无效的staleSlot索引上,新建一个Entry对象
            tab[staleSlot].value = null;
            tab[staleSlot] = new Entry(key, value);

            // If there are any other stale entries in run, expunge them
            //2者不相等,则清除其他无效的entry
            if (slotToExpunge != staleSlot)
                cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
        }

清空无效节点

```java
 private int expungeStaleEntry(int staleSlot) {
            Entry[] tab = table;
            int len = tab.length;

            // expunge entry at staleSlot
            //清空value和索引对象
            tab[staleSlot].value = null;
            tab[staleSlot] = null;
            //数组里面的值大小-1
            size--;

            // Rehash until we encounter null
            Entry e;
            int i;
            //向后遍历
            for (i = nextIndex(staleSlot, len);
                 (e = tab[i]) != null;
                 i = nextIndex(i, len)) {

                ThreadLocal<?> k = e.get();
                //清除过期的key
                if (k == null) {
                    e.value = null;
                    tab[i] = null;
                    size--;
                } else {
                    int h = k.threadLocalHashCode & (len - 1);
                    //重新计算k的索引,判断是否和当前i冲突
                    if (h != i) {
                        tab[i] = null;

                        // Unlike Knuth 6.4 Algorithm R, we must scan until
                        // null because multiple entries could have been stale.
                        //获取下一个tab为null的位置,赋值e
                        //这里实际上是将e移动到靠近h的后驱节点上,这样get/set就方便查找
                        while (tab[h] != null)
                            h = nextIndex(h, len);
                        //存储e
                        tab[h] = e;
                    }
                }
            }
            //返回下一个为空的entry的索引
            return i;
        }
        
 private boolean cleanSomeSlots(int i, int n) {
            boolean removed = false;
            Entry[] tab = table;
            int len = tab.length;
            //遍历下一个节点,如果查找到无效节点,则删除
            do {
                i = nextIndex(i, len);
                Entry e = tab[i];
                if (e != null && e.get() == null) {
                    //重置n为tab长度
                    n = len;
                    removed = true;
                    i = expungeStaleEntry(i);
                }
            } while ( (n >>>= 1) != 0);//无符号右移,控制扫描次数log2(N)
            return removed;
        }

扩容

  private void rehash() {
            //清除所有无效节点
            expungeStaleEntries();

            // Use lower threshold for doubling to avoid hysteresis
            //2/3*len-2/3*len/4=1/2*len
            //size >= 1/2*len
            if (size >= threshold - threshold / 4)
                resize();
        }

 private void expungeStaleEntries() {
            Entry[] tab = table;
            int len = tab.length;
            for (int j = 0; j < len; j++) {
                Entry e = tab[j];
                if (e != null && e.get() == null)
                    expungeStaleEntry(j);
            }
        }

 private void resize() {
            Entry[] oldTab = table;
            int oldLen = oldTab.length;
            //长度扩容一倍
            int newLen = oldLen * 2;
            Entry[] newTab = new Entry[newLen];
            int count = 0;

            for (int j = 0; j < oldLen; ++j) {
                Entry e = oldTab[j];
                if (e != null) {
                    ThreadLocal<?> k = e.get();
                    //再次检测无效引用则清理
                    if (k == null) {
                        e.value = null; // Help the GC
                    } else {
                        //循环获取无效位置然后赋值
                        int h = k.threadLocalHashCode & (newLen - 1);
                        while (newTab[h] != null)
                            h = nextIndex(h, newLen);
                        newTab[h] = e;
                        count++;
                    }
                }
            }

            //设置新的扩容长度限制
            setThreshold(newLen);
            size = count;
            table = newTab;
        }

get

 public T get() {
        //获取当前线程
        Thread t = Thread.currentThread();
        //获取当前线程map
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            //根据当前ThreadLocal获取value
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                @SuppressWarnings("unchecked")
                        //获取值,并返回
                T result = (T)e.value;
                return result;
            }
        }
        //map为空则初始化value
        return setInitialValue();
    }

private T setInitialValue() {
        //初始化值为null
        T value = initialValue();
        //获取当前线程
        Thread t = Thread.currentThread();
        //获取map
        ThreadLocalMap map = getMap(t);
        if (map != null)
            //否则设置值
            map.set(this, value);
        else
            //map为空则创建map,并赋值
            createMap(t, value);
        return value;
    }

        private Entry getEntry(ThreadLocal<?> key) {
            //算出索引
            int i = key.threadLocalHashCode & (table.length - 1);
            Entry e = table[i];
            //根据key获取Entry
            if (e != null && e.get() == key)
                return e;
            else
                //没有获取,则说明要么失效了,要么存在在后续节点
                return getEntryAfterMiss(key, i, e);
        }

 private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
            Entry[] tab = table;
            int len = tab.length;

            while (e != null) {
                ThreadLocal<?> k = e.get();
                //匹配,则返回
                if (k == key)
                    return e;
                //说明失效,则删除失效节点
                if (k == null)
                    expungeStaleEntry(i);
                else
                    //没有失效,继续遍历后续节点
                    i = nextIndex(i, len);
                e = tab[i];
            }
            return null;
        }

remove

     public void remove() {
         //获取当前线程map
         ThreadLocalMap m = getMap(Thread.currentThread());
         if (m != null)
             //删除当前值
             m.remove(this);
     }
   private void remove(ThreadLocal<?> key) {
            Entry[] tab = table;
            int len = tab.length;
            int i = key.threadLocalHashCode & (len-1);
            //遍历Entry
            for (Entry e = tab[i];
                 e != null;
                 e = tab[i = nextIndex(i, len)]) {
                //删除当前ThreadLocal对应的value
                if (e.get() == key) {
                    //清空referent
                    e.clear();
                    expungeStaleEntry(i);
                    return;
                }
            }
        }

总结

扩容时机,当前集合个数超过len*3/4
Entry继承WeakReference,也就是说当一个对象仅仅被weak reference指向,而没有任何其他strong reference指向的时候, 如果GC运行, 那么这个对象就会被回收.
底层数组存储ThreadLocal和val,采用hashcode获取索引

为什么采用弱引用?因为当采用强引用的时候,如果ThreadLocal为空的时候,GC依旧不会清空存储的值,会造成内存泄漏
在threadLocal的生命周期里（set,getEntry,remove）里，都会针对key为null的脏entry进行处理。

PriorityBlockingQueue

一个无界阻塞队列，它使用与类 PriorityQueue 相同的顺序规则，并且提供了阻塞获取操作。

//todo

SynchronousQueue

其中每个插入操作必须等待另一个线程的对应移除操作

//todo

ConcurrentSkipListMap

//todo

可缩放的并发 ConcurrentNavigableMap 实现。映射可以根据键的自然顺序进行排序，也可以根据创建映射时所提供的 Comparator 进行排序，具体取决于使用的构造方法。

AtomicReferenceFieldUpdater

原子域更新器

//todo