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

淩亂°似流年 2023-02-12 09:26 3阅读 0赞

### 文章目录 ###

*   *  本篇文章主要是对JUC包下,一些并发类的源码分析,如果想了解具体实例,请点击
 *  并发容器
 *   *  ConcurrentHashMap
     *   *  put
         *  初始化
         *  扩容
         *  get
         *  replace\#remove
         *  总结:
     *  CopyOnWriteArrayList
     *   *  add
         *  remove
         *  get
         *  set
     *  总结
     *  LinkedBlockingQueue
     *   *  put
         *  offer
         *  阻塞时间的offer
         *  take
         *  poll
         *  peek
         *  remove
         *  迭代器
         *  总结
     *  ArrayBlockingQueue
     *   *  put
         *  offer
         *  take
         *  remove
         *  总结
 *  ThreadLocal
 *   *  set
     *   *  初始化ThreadLocalMap
         *  set赋值
         *  重新使用失效节点
         *  清空无效节点
         *  扩容
     *  get
     *  remove
     *  总结
 *  PriorityBlockingQueue
 *   *   *  //todo
 *  SynchronousQueue
 *   *   *  //todo
 *  ConcurrentSkipListMap
 *   *   *  //todo
 *  AtomicReferenceFieldUpdater
 *   *   *  //todo

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

# 并发容器 #

## ConcurrentHashMap ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70]

//使用了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指向了自己,  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70 1]

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 ###

[JUC]: https://editor.csdn.net/md/?articleId=106336998
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200525225014811.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200526151439409.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw==,size_16,color_FFFFFF,t_70