实战系列-Java中线程安全集合类(一)

浅浅的花香味﹌ 2022-10-18 01:30 226阅读 0赞

> **导语**  
>   在Java开发中我们经常会遇到集合类线程安全的问题，在Java语言的发展过程中，从最初的线程不安全的集合类，到现在基本上支持很多的线程安全的集合类，在开发过程中，有些场景中不需要注意线程安全问题，当时在一个并发场景中就必须要使用到线程安全的集合类，那么下面就来看看在Java中比较常见的线程安全集合类以及其原理。

### 文章目录 ###

*   *  ConcurrentHashMap原理
     *  ConcurrentSkipListMap原理
     *  CopyOnWriteArrayList原理
     *  ConcurrentLinkedQueue原理
     *  LinkedBlockingQueue

## ConcurrentHashMap原理 ##

ConcurrentHashMap是线程安全且高效的HashMap集合类，在工作环境中并发与多线程的工作是难免的，这时候类似于HashMap这样的线程不安全的集合类就不能胜任这个需求了，为了满足在多线程场景下安全高效的开发工作，这个时候ConcurrentHashMap就出现了，这个是由JDK 本身来提供的。

**两个问题**

*  1、为什么HashMap在多线程下是不安全的？  
      HashMap在多线程环境下进行put操作会引起死循环，导致CPU的利用率达到100%
 *  2、是什么导致的不安全的事情发生？  
      HashMap在并发执行put操作的时候，导致HashMap的Entry链表形成环形数据结构，然后Entry的next一直有值，永远向下获取。

这里需要注意的是HashTable虽然具有线程安全的特点，但是锁的粒度比较大，将整个数组都进行了加锁操作，在多线程对table读写操作时竞争非常激烈，严重的时候就会影响性能。所以HashTable虽然是线程安全的，但是效率比较低，一般不会使用到。

在JDK1.7中，ConcurrentHashMap使用了锁分段技术，将HashMap数组分成了一段一段加锁，在并发访问不同的数据段的时候，每个线程可以获取每个段上的自己的锁，数据段之间相互不影响。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25paHVpMTIz_size_16_color_FFFFFF_t_70_pic_center]  
  Segment数组是需要获取的可重入锁，HashEntry是每一个锁下的数据段，与HashMap的数据结构相似，由数组加链表组成，这样就完成了对HashMap数组的分段锁，每次想要对数据段内容进行操作，就需要首先获取相应的可重入锁。

JDK1.8后，对ConcurrentHashMap进行的改造，编程了数组+链表+红黑树的结构，锁的粒度调整为每个链表的头结点，定位结点的Hash算法简化了，这样会加大Hash冲突，所以当链表中的元素个数超过8个的时候，链表转换成红黑树进行存储，采用Node+CAS+Synchronized保证安全并发。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25paHVpMTIz_size_16_color_FFFFFF_t_70_pic_center 1]  
  ConcurrentHashMap初始化在第一个put方法执行时才会发生，初始化调用initTable()方法如下  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25paHVpMTIz_size_16_color_FFFFFF_t_70_pic_center 2]  
 &emps;如果当前正在执行初始化操作，且初始化的线程不是当前线程，则当前线程让出时间片，如果是当前线程的话还要进行一个CAS安全校验，判断是否有人抢先进行初始化操作，都没有的话才会进行初始化操作。

**put方法**  
  在执行put方法插入数据时，根据key的hash值，在Node数组中找到相应的位置，实现如下  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25paHVpMTIz_size_16_color_FFFFFF_t_70_pic_center 3]![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25paHVpMTIz_size_16_color_FFFFFF_t_70_pic_center 4]  
**从上往下**

*  1、如果数组为空，首先进行初始化
 *  2、如果当前的位置没有链表，采用CAS的方式在此位置加上Node节点
 *  3、如果当前Map正在扩容，首先协助扩容，然后进行数值更新
 *  4、如果有Hash冲突，首先给产生冲突的头结点处加上synchronized,添加的值已经存在的话，就更新操作；添加的值要是不存在的话，将新值添加到链表的末尾。如果链表已经转为红黑树了，性质将以树节点的形式添加。
 *  5、如果添加了新值之后影响了链表的长度，使得链表达到了转换为红黑树的阈值，使用treeifyBin()方法对链表进行转化。
 *  6、最后统计总结点的个数，是不是达到阈值需要扩容操作。

**扩容**  
  当进行新增节点时，两种方式会触发扩容，第一是链表长度大于等于8，当前数组长度小于64，数组长度会扩容为原来的两倍；第二十addCount()会统计数组中节点的个数，如果新增节点个数大于阈值，会触发transfer，重新调整节点位置。  
  在扩容的过程中依然支持并发更新和并发插入，遍历整个table，当前节点为空，则采用CAS方式在当前位置放入fwd，每个线程承担不小于16个元素的扩容，从右向左划分16个，每当开始迁移一个元素的时候，线程会锁住该元素（Node链表）头结点，如果插入、修改、删除、合并等操作遇到了ForwardingNode，当前线程也会加入到扩容大军中,扩容结束后再进行更新操作。

get方法相对于put方法来说都比较简单，根据key计算hash值获取到在数组的位置，如果key为空返回null，否则返回值。

clear方法，首先遍历table中的每一个bucket，如果当前bucket正在扩容，先帮忙完成扩容，然后给当前bucket上锁删除元素，更新map的size。

## ConcurrentSkipListMap原理 ##

了解ConcurrentSkipListMap首先要了解SkipMap是什么？

**SkipMap**  
  传统的单链表是一个线性结构，我们想向链表中插入一个节点需要O(n)时间，查找也需要O(n)时间。  
  跳跃表简单的示例：  
![在这里插入图片描述][20210605162918447.jpeg_pic_center]  
  如果我们使用了上图所示的跳表，就可以将查找时间缩短为O(n/2)，我们可以先通过每个节点上边的指针先进性查找，这样就可以跳过一半的节点。  
  跳表是一种可以代替平衡树的数据结构，默认按照key值升序，SkipList让已排序的数据分布在多层链表中，以0-1随机数决定一个数据的向上攀升与否，通过“空间来换取时间”的一个算法，在每个节点中增加了向前的指针，在插入、删除、查找时可以忽略一些不可能涉及到的节点，从而提高了效率。

**ConcurrentSkipListMap**  
  ConcurrentSkipListMap提供了一种线程安全的并发访问的排序映射表，内部是SkipList结构，在理论上能够在O(log(n))时间内完成查找、插入、删除操作。  
  在非多线程的情况下，应当尽量使用TreeMap。此外对于并发性相对较低的并行程序可以使用Collection.synchronizedSortedMap将TreeMap进行包装，也可以提供较好的效率。对于高并发的程序，应当使用ConcurrentSkipListMap，能够提供高效的并发度。所以在多线程程序中，如果需要对Map的值进行排序的时候，尽量使用ConcurrentSkipListMap，可以得到更好的并发度。

ConcurrentSkipListMap主要用到了Node和Index两种节点存储方式，通过volatile关键字实现了并发操作。

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

**跳表存储结构**

*  1、最底层的节点按照关键字升序排列(key是有序的)
 *  2、包含多级索引，每个级别的索引节点按照其关联数据节点的关键字升序排列。
 *  3、高级别索引是其低级别索引的子集
 *  4、如果关键字key在级别level=i的索引中出现，则级别level<=i的所有索引中包含key。

static final class Node<K,V> {     //最底下一层的链表节点
            final K key;  
            volatile Object value;//value值 
            volatile Node<K,V> next;//next引用 
            ……  
    }  
    static class Index<K,V> {    //上层的索引分类
            final Node<K,V> node;  
            final Index<K,V> down;//downy引用 
           volatile Index<K,V> right;//右边引用 
           ……  
    }

**查找**

通过SkipList的方式进行查找操作  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25paHVpMTIz_size_16_color_FFFFFF_t_70_pic_center 6]  
  红色虚线为查找路径，蓝色箭头为right引用，黑色箭头为down引用

首先查找最高层，没有查找的key在向下层查找

public V get(Object key) { 
        return doGet(key);
    }

doGet()

private V doGet(Object key) { 
        if (key == null)
            throw new NullPointerException();
        Comparator<? super K> cmp = comparator;
        outer: for (;;) { 
            for (Node<K,V> b = findPredecessor(key, cmp), n = b.next;;) { 
                Object v; int c;
                if (n == null)
                    break outer;
                Node<K,V> f = n.next;
                if (n != b.next)                // inconsistent read
                    break;
                if ((v = n.value) == null) {     // n is deleted
                    n.helpDelete(b, f);
                    break;
                }
                if (b.value == null || v == n)  // b is deleted
                    break;
                if ((c = cpr(cmp, key, n.key)) == 0) { 
                    @SuppressWarnings("unchecked") V vv = (V)v;
                    return vv;
                }
                if (c < 0)
                    break outer;
                b = n;
                n = f;
            }
        }
        return null;
    }

doGet()通过findPredecessor()方法根据key获取节点，然后经过判断将value进行返回。这里在并发场景下，获取到节点后，难免会有其他线程再给节点删除。

**删除**

final V doRemove(Object key, Object value) { 
        if (key == null)
            throw new NullPointerException();
        Comparator<? super K> cmp = comparator;
        outer: for (;;) { 
            for (Node<K,V> b = findPredecessor(key, cmp), n = b.next;;) { 
                Object v; int c;
                if (n == null)
                    break outer;
                Node<K,V> f = n.next;
                if (n != b.next)                    // inconsistent read
                    break;
                if ((v = n.value) == null) {         // n is deleted
                    n.helpDelete(b, f);
                    break;
                }
                if (b.value == null || v == n)      // b is deleted
                    break;
                if ((c = cpr(cmp, key, n.key)) < 0)
                    break outer;
                if (c > 0) { 
                    b = n;
                    n = f;
                    continue;
                }
                if (value != null && !value.equals(v))
                    break outer;
                if (!n.casValue(v, null))
                    break;
                if (!n.appendMarker(f) || !b.casNext(n, f))
                    findNode(key);                  // retry via findNode
                else { 
                    findPredecessor(key, cmp);      // clean index
                    if (head.right == null)
                        tryReduceLevel();
                }
                @SuppressWarnings("unchecked") V vv = (V)v;
                return vv;
            }
        }
        return null;
    }

首先将节点的value设为null，然后添加删除标记，这两步都会被视为节点删除。用findPredecessor方法里的unlink清除链表中的节点，helpdelete方法会检测当前节点是否添加删除标记，未添加则添加标记，添加标记的将前驱节点指向当前节点的next。

**Put**

JDK中相应做了更新，将insertIindex和addIndex全部整合到doPut一个方法里面。大概意思是，通过findPredecessor方法寻找小于等于key节点合适的位置，如果是小于就把小于key的前驱节点返回，等于的话就把相应的值做更新。由于是考虑到并发，死循环过程中会检测修改或前驱节点的值是否被删除或者是否发生更新。节点value被修改为null或者添加了删除标记的，在链表中将节点做相应的清除。如果链表中有相应的key，用CAS方式不停的把key的value做更新，直到成功为止。如果没有相应的key，需要添加新节点，next指向n，用CAS的方式构建b->新节点->n 的链表。

添加新节点后计算随机level的等级，在满足原来链表结构的条件下，中间添加了新的节点，链表的结构为了维持原来的样子必须做出调整，从最底层向上添加节点，通过down连接，如果修改过程中发生level等级小于当前的level等级了，那说明其他线程完成了对level等级的更新。第一个更新的使用CAS的方式来对头节点进行更新。

## CopyOnWriteArrayList原理 ##

CopyOnWriteArrayList是一个线程安全的ArrayList,对其的修改操作是在底层的复制数组上进行的，使用写时复制策略。其内部使用ReenTrantLock来对集合进行加锁，保证只有一个线程同时对集合进行修改。  
  添加元素add方法，有很多重构的方法，其原理相同，add(E e)，add(int index,E e),当前是add方法，在列表的末尾添加元素。

public boolean add(E e) { 
        final ReentrantLock lock = this.lock;
        lock.lock();
        try { 
            Object[] elements = getArray();
            int len = elements.length;
            Object[] newElements = Arrays.copyOf(elements, len + 1);
            newElements[len] = e;
            setArray(newElements);
            return true;
        } finally { 
            lock.unlock();
        }
    }

首先获得Reentrantlock，创建一个比原数组长度大1 的新数组，将原数组中的元素复制到新数组中，在末尾添加上新的元素，将新数组设置为当前数组，最后进行锁释放。

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

为了实现并发的安全性，每次修改都会先加入独占锁。判断修改的值和对应的位置上的值是否相等，相等就不用操作，直接返回，不相等的话创建新数组，修改完值用新数组替换。

**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;
            if (numMoved == 0)
                setArray(Arrays.copyOf(elements, len - 1));
            else { 
                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();
        }
    }

如果是最后一个直接复制数组的除去末尾的部分，如果是在中间，使用arrayCory方法从elements数组复制到new数组中，返回删除的元素。

**Get方法**

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

该方法没有加任何的安全保护机制，是线程不安全的。如果获取到数组后又被其他线程修改，则获取到的值不是最新的，这是写时复制策略产生的弱一致性原理。  
  在迭代器遍历的时候也会存在这个问题，迭代遍历的数组和修改的数组是不同步的。

## ConcurrentLinkedQueue原理 ##

ConcurrentLinkedQueue是一个基于链接节点的线程安全的无界队列，它采用先进先出的规则对节点进行排序。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25paHVpMTIz_size_16_color_FFFFFF_t_70_pic_center 7]  
  ConcurrentLinkedQueue 由head节点和tail节点构造成，head指向头结点，tail不总是指向尾节点，节点之间通过next连接起来。默认的时候也就是节点为空的时候，head和tail都指向头结点，节点和指向下一个节点的引用都使用volatile关键字声明，Node中的方法都使用CAS的方式实现其安全性。

**入队操作**

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

上图所示的元素添加过程如下

*  添加元素1：队列更新head节点的next节点为元素1节点。又因为tail节点默认情况下等于head节点，所以它们的next节点都指向元素1节点。
 *  添加元素2：队列首先设置元素1节点的next节点为元素2节点，然后更新tail节点指向元素2节点。
 *  添加元素3：设置tail节点的next节点为元素3节点。
 *  添加元素4：设置元素3的next节点为元素4节点，然后将tail指向元素4节点。

tail 节点与时指向倒数第二个元素，有时指向队列末尾元素。

public boolean add(E e) { 
        return offer(e);
    }
    
    public boolean offer(E e) { 
        checkNotNull(e);
        final Node<E> newNode = new Node<E>(e);
    
        for (Node<E> t = tail, p = t;;) { 
            Node<E> q = p.next;
            if (q == null) { 
                // p is last node
                if (p.casNext(null, newNode)) { 
                    // Successful CAS is the linearization point
                    // for e to become an element of this queue,
                    // and for newNode to become "live".
                    if (p != t) // hop two nodes at a time
                        casTail(t, newNode);  // Failure is OK.
                    return true;
                }
                // Lost CAS race to another thread; re-read next
            }
            else if (p == q)
                // We have fallen off list. If tail is unchanged, it
                // will also be off-list, in which case we need to
                // jump to head, from which all live nodes are always
                // reachable. Else the new tail is a better bet.
                p = (t != (t = tail)) ? t : head;
            else
                // Check for tail updates after two hops.
                p = (p != t && t != (t = tail)) ? t : q;
        }
    }

首先创建新节点，根据tail节点确定尾节点的位置。如果tail节点的next为空，则tail节点为尾节点。如果tail节点为尾节点，设置新入队的节点为tail的next节点，使用CAS方式循环设置，如果失败就在此尝试。如果tail不是尾节点，将tail指向新的节点，使用CAS方式设置新节点为尾节点，这个时候tail指向了尾节点。考虑到并发，这里是设计了一个判断，如果p!=t,说明其他线程更新成功。

tail不设置总是指向尾节点是为了提升CAS的效率，目的是提高入队效率。1.7中douglea使用hops变量来控制并减少tail节点更新的频率，当tail节点和尾节点的距离大于等于常量hops的值默认等于1的时候才更新tail节点，tail和尾节点的距离越长使用CAS更新tail节点的次数就越少，但是距离变长定位尾节点的时间就越长，循环体需要多循环一次定位尾节点。本质上增加了volatile的读操作减少了写操作，写比读的开销大，所以入队效率会提升。1.8中tail的更新是通过p和t是否相等来进行判断，其实现结果和1.7 是相同的，即当tail节点和尾节点的距离大于等于1的时候，更新tail。

**出队操作**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25paHVpMTIz_size_16_color_FFFFFF_t_70_pic_center 9]

当前head为空时，弹出head的下一个节点，并更新头节点，当head不为空的时候，弹出当前节点的值，并用CAS方式把节点设置为null，CAS成功后返回头节点的值，不更新头结点。

public E poll() { 
        restartFromHead:
        for (;;) { 
            for (Node<E> h = head, p = h, q;;) { 
                E item = p.item;
    // 如果p节点的元素不为null，则通过CAS来设置p节点引用的元素为null，如果成功则返回p节点的元素
                if (item != null && p.casItem(item, null)) { 
                    // Successful CAS is the linearization point
                    // for item to be removed from this queue.
    // 如果p != h，则更新head
                    if (p != h) // hop two nodes at a time
                        updateHead(h, ((q = p.next) != null) ? q : p);
                    return item;
                }
    // 如果头节点的元素为空或头节点发生了变化，这说明头节点已经被另外一个线程修改了。
    // 那么获取p节点的下一个节点，如果p节点的下一节点为null，则表明队列已经空了
                else if ((q = p.next) == null) { 
                    updateHead(h, p);
                    return null;
                }
    // p == q，则使用新的head重新开始
                else if (p == q)
                    continue restartFromHead;
    // 如果下一个元素不为空，则将头节点的下一个节点设置成头节点
                else
                    p = q;
            }
        }
    }

peek方法获取链表的首部元素，不会移除首部元素

public E peek() { 
        restartFromHead:
        for (;;) { 
            for (Node<E> h = head, p = h, q;;) { 
                E item = p.item;
                if (item != null || (q = p.next) == null) { 
                    updateHead(h, p);
                    return item;
                }
                else if (p == q)
                    continue restartFromHead;
                else
                    p = q;
            }
        }
    }

**Size方法**  
  获取队列的元素个数，并发过程中可能会不准确，因为该获取过程没有加锁，期间增删元素不会记录。

**Remove方法**  
  获取队首元素，如果队首元素不为空，元素的值和传入的值相同就可以通过CAS把值设置成NULL，调整前驱的next指向当前的next；不相等则获取下一个节点，重复上述操作即可。

public boolean remove(Object o) { 
    // 删除的元素不能为null
        if (o != null) { 
            Node<E> next, pred = null;
            for (Node<E> p = first(); p != null; pred = p, p = next) { 
                boolean removed = false;
                E item = p.item;
    // 节点元素不为null
                if (item != null) { 
    // 若不匹配，则获取next节点继续匹配
                    if (!o.equals(item)) { 
                        next = succ(p);
                        continue;
                    }
    // 若匹配，则通过CAS操作将对应节点元素置为null
                    removed = p.casItem(item, null);
                }
    // 获取删除节点的后继节点
                next = succ(p);
    // 将被删除的节点移除队列
                if (pred != null && next != null) // unlink
                    pred.casNext(p, next);
                if (removed)
                    return true;
            }
        }
        return false;
    }

## LinkedBlockingQueue ##

LinkedBlockingQueue如果不指定容量的话，默认大小是Integer.MAX\_VALUE。也就是无界队列。为避免队列过大造成机器负载或者内存爆满的情况出现，一般建议传入一个队列大小。区别于ConcurrentLinkedQueue 的是这个是阻塞队列，ConcurrentLinkedQueue是非阻塞的。

阻塞队列的大小，默认为Integer.MAX\_VALUE

private final int capacity;

记录当前队列元素个数

private final AtomicInteger count = new AtomicInteger();

头结点

transient Node<E> head;

尾结点

private transient Node<E> last;

获取到元素操作如take poll 时加的锁

private final ReentrantLock takeLock = new ReentrantLock();

添加元素时获取的锁如put offer 等

private final ReentrantLock putLock = new ReentrantLock();

这里内部使用了takeLock和putLock进行并发控制，添加和删除不是互斥的，可以同时进行。

**入队方法put(E e)**

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);
        final ReentrantLock putLock = this.putLock;
        final AtomicInteger count = this.count;
    获取锁中断
        putLock.lockInterruptibly();
        try { 
            判断队列是否已满，如果已满，阻塞等待
            while (count.get() == capacity) { 
                notFull.await();
            }
    把node放入队列中
            enqueue(node);
            c = count.getAndIncrement();
    再次判断队列是否有可用空间，如果有唤醒下一个线程进行添加操作
            if (c + 1 < capacity)
                notFull.signal();
        } finally { 
            putLock.unlock();
        }
    如果队列中有一条数据，唤醒消费线程进行消费
        if (c == 0)
            signalNotEmpty();
    }

队列已满，阻塞等待。队列未满，创建节点放入队列，如果放完还有剩余空间，继续唤醒下一个添加线程继续添加。如果放入前队列为空，放完后要唤醒消费线程进行消费。

private void enqueue(Node<E> node) { 
        // assert putLock.isHeldByCurrentThread();
        // assert last.next == null;
        last = last.next = node;
    }

进队列后将尾节点指向新节点，将当前尾节点的next指向新节点。

Offer有两个重载，一个是向队列中放入元素，给定一个等待时间，超过时间后还是没有可用的，就返回false。另一个是添加元素没有可用空间直接返回false。  
**出队**  
**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;
    }

队列为空，阻塞队列。队列不为空，从队首获取并移除一个元素，如果消费后还有元素再队列中，继续唤醒下一个消费线程进行元素移除。如果放之前队列是满的，移完后要唤醒生产线程进行添加元素。  
**dequeue方法**

private E dequeue() { 
        // assert takeLock.isHeldByCurrentThread();
        // assert head.item == null;
        Node<E> h = head;
        Node<E> first = h.next;
        h.next = h; // help GC
        head = first;
        E x = first.item;
        first.item = null;
        return x;
    }

获取头节点后第一个元素的值并返回，设置此元素item为空，将此元素设置为头节点。

**poll方法**

public E poll() { 
        final AtomicInteger count = this.count;
        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();
        }
    }

获取锁后，头节点的next节点为空就返回null，否则返回next节点的值。

**Remove方法**

public boolean remove(Object o) { 
        if (o == null) return false;
        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 { 
            fullyUnlock();
        }
    }

Remove方法takeLock和putLock都上锁了，其他的方法都被阻塞等待remove方法执行完成

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25paHVpMTIz_size_16_color_FFFFFF_t_70_pic_center]: /images/20221014/8519ebe13b634561ac12a3dd7e5c9c2f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25paHVpMTIz_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221014/995eb91a48084563a4b469766a53995f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25paHVpMTIz_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221014/959390cdc73d46bf997e89e15759f895.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25paHVpMTIz_size_16_color_FFFFFF_t_70_pic_center 3]: https://img-blog.csdnimg.cn/20210604155456170.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25paHVpMTIz,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25paHVpMTIz_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20221014/fa046b3bbcbc454182469fa8103807b5.png
[20210605162918447.jpeg_pic_center]: /images/20221014/30ec288368bf4af9a7fd770233c63916.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25paHVpMTIz_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20221014/10eb47bed4d0456fa34156cd41565da7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25paHVpMTIz_size_16_color_FFFFFF_t_70_pic_center 6]: /images/20221014/66d11696ffb14b4192261e76fdc9b73f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25paHVpMTIz_size_16_color_FFFFFF_t_70_pic_center 7]: /images/20221014/28314366a5fb4e5eb24c26eb4ab8a0ef.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25paHVpMTIz_size_16_color_FFFFFF_t_70_pic_center 8]: /images/20221014/69b1ed7f5a244166b46eb64bcc959f25.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25paHVpMTIz_size_16_color_FFFFFF_t_70_pic_center 9]: /images/20221014/7052dfcc544b4dfa92a0543b06d7a4c5.png