JDK源码——线程安全的队列

抽象类

AbstractQueue

clear()方法没有参数且返回类型为void，意味着它不返回任何值；

element()方法同样没有参数，但返回类型为E，表示它返回队列中的元素；

addAll(Collection<? extends E>)方法接受一个集合作为参数，并且返回类型为boolean，表示它将多个元素添加到队列中并返回操作是否成功；

remove()方法返回类型也是E，但它从队列中移除并返回头部元素；

add(E)方法接受一个元素作为参数，返回类型为boolean，表示它尝试将元素添加到队列中并返回是否成功。

实现类

ArrayBlockingQueue

ArrayBlockingQueue 是 Java 中的一个阻塞队列，它是一个基于数组的有界阻塞队列。当队列满时，尝试插入元素的线程会被阻塞；当队列为空时，尝试取出元素的线程会被阻塞。ArrayBlockingQueue 常用于生产者-消费者模式中，以确保生产者不会在缓冲区满时继续添加元素，同时确保消费者在缓冲区空时不会尝试获取元素。

类方法如下：

1. enqueue(E): void - 将指定的元素插入到此队列中。如果立即可行且不会违反容量限制，则返回 true；否则会抛出 IllegalStateException。
2. dequeue(): E - 移除并返回此队列的头部元素。如果此队列为空，则抛出 NoSuchElementException。
3. readObject(ObjectInputStream): void - 从 ObjectInputStream 中读取队列。
4. toString(): String - 返回此队列的字符串表示形式。
5. poll(): E - 检索并移除此队列的头部，如果此队列为空，则返回 null。
6. put(E): void - 将指定的元素插入到此阻塞队列中，在必要时等待空间可用。
7. peek(): E - 查看此队列的头部，但不移除它。如果此队列为空，则返回 null。
8. remove(Object): boolean - 如果存在，则从队列中移除一个等于指定对象的元素的单个实例。
9. toArray(): Object[] - 返回一个包含此队列所有元素的数组。
10. poll(long, TimeUnit): E? - 从此队列中移除并返回队头元素，在指定的时间内等待空间可用。如果在指定时间内没有可用的空间，则返回 null。
11. take(): E - 检索并移除此队列的头部，在必要时等待直到元素可用。
12. remainingCapacity(): int - 返回当前队列剩余的容量。
13. clear(): void - 清空此队列。
14. drainTo(Collection, int): int - 移除此队列中的所有可用元素并将它们添加到给定集合中，最多移除给定数量的元素。
15. iterator(): Iterator - 返回此队列中元素的迭代器。
16. size(): int - 返回此队列中的元素数量。
17. contains(Object): boolean - 如果此队列包含指定的元素，则返回 true。
18. add(E): boolean - 将指定的元素插入到此队列中（如果立即可行且不会违反容量限制）。
19. offer(E): boolean - 将指定的元素插入到此队列中，如果立即可行且不会违反容量限制，则返回 true；否则返回 false。
20. itemAt(int): E - 返回指定索引处的元素。
21. offer(E, long, TimeUnit): boolean - 将指定的元素插入到此队列中，在指定的时间内等待空间可用。如果在指定时间内没有可用的空间，则返回 false。
22. toArray(T[]): T[] - 返回一个包含此队列所有元素的数组；返回数组的运行时类型是指定数组的类型。
23. drainTo(Collection): int - 移除此队列中的所有可用元素并将它们添加到给定集合中。
24. spliterator(): Spliterator - 创建一个弱一致的 Spliterator 来遍历此队列中的元素。
25. dec(int): int - 递减给定值。
26. checkNotNull(Object): void - 检查对象是否为 null，如果是，则抛出 NullPointerException。
27. removeAt(int): void - 移除指定索引处的元素。

ConcurrentLinkedQueue

ConcurrentLinkedQueue 是 Java 中的一个线程安全的无界非阻塞队列，它实现了 java.util.concurrent.BlockingQueue 接口。这个队列的元素遵循先进先出（FIFO）的原则进行排列。

类方法如下：

1. peek(): E - 返回队列头部的元素，但不移除它。如果队列为空，则返回 null。
2. first(): Node - 返回队列头部的节点。
3. casHead(Node, Node): boolean - 使用原子操作尝试更新队列头部节点。
4. contains(Object): boolean - 如果队列包含指定的元素，则返回 true。
5. succ(Node): Node - 获取给定节点的下一个节点。
6. size(): int - 返回队列中的元素数量。
7. checkNotNull(Object): void - 检查对象是否为 null，如果是，则抛出 NullPointerException。
8. casTail(Node, Node): boolean - 使用原子操作尝试更新队列尾部节点。
9. poll(): E - 检索并移除此队列的头部，如果此队列为空，则返回 null。
10. offer(E): boolean - 将指定的元素插入到此队列中，如果立即可行且不会违反容量限制，则返回 true；否则返回 false。
11. isEmpty(): boolean - 如果此队列不包含任何元素，则返回 true。
12. readObject(ObjectInputStream): void - 从 ObjectInputStream 中读取队列。
13. toArray(T[]): T[] - 返回一个包含此队列所有元素的数组；返回数组的运行时类型是指定数组的类型。
14. toArray(): Object[] - 返回一个包含此队列所有元素的数组。
15. add(E): boolean - 将指定的元素插入到此队列中（如果立即可行且不会违反容量限制）。
16. addAll(Collection): boolean - 将指定集合中的所有元素添加到此队列中。
17. spliterator(): Spliterator - 创建一个弱一致的 Spliterator 来遍历此队列中的元素。
18. remove(Object): boolean - 如果存在，则从队列中移除一个等于指定对象的元素的单个实例。
19. writeObject(ObjectOutputStream): void - 将此队列写入 ObjectOutputStream。
20. iterator(): Iterator - 返回此队列中元素的迭代器。
21. updateHead(Node, Node): void - 更新队列头部节点。

LinkedBlockingQueue

LinkedBlockingQueue 是 Java 中的一个阻塞队列，它实现了 BlockingQueue 接口。它是一个线程安全的队列，可以在多线程环境下使用。当队列为空时，获取元素的操作会被阻塞，直到有元素可用；当队列已满时，插入元素的操作会被阻塞，直到有空间可用。这种特性使得 LinkedBlockingQueue 非常适合用于生产者-消费者模式。

类方法如下：

• pollLast(): 检索并移除此双端队列的最后一个元素，如果此双端队列为空，则返回 null。
• removeFirstOccurrence(Object o): 从此双端队列中移除第一次出现的指定元素（如果存在）。
• unlinkLast(): 移除并返回此双端队列的最后一个元素。
• putLast(E e): 将指定的元素插入此双端队列的末尾。
• remainingCapacity(): 返回此双端队列在不超出其容量限制的情况下可以包含的元素数量。
• drainTo(Collection<? super E> c, int maxElements): 移除此双端队列中的所有可用元素并将它们添加到给定集合中，最多添加 maxElements 个元素。
• element(): 检索但不移除此双端队列的第一个元素；如果此双端队列为空，则抛出异常。
• peekFirst(): 检索但不移除此双端队列的第一个元素，如果此双端队列为空，则返回 null。
• removeLastOccurrence(Object o): 从此双端队列中移除最后一次出现的指定元素（如果存在）。
• drainTo(Collection<? super E> c): 移除此双端队列中的所有可用元素并将它们添加到给定集合中。
• put(E e): 将指定的元素插入到此双端队列的末尾。
• writeObject(ObjectOutputStream s): 将此双端队列的内容写入到指定的 ObjectOutputStream。
• remove(Object o): 从此双端队列中移除第一次出现的指定元素（如果存在）。
• pollLast(long timeout, TimeUnit unit): 检索并移除此双端队列的最后一个元素，如果在指定的等待时间内此双端队列没有变为非空，则返回 null。
• takeFirst(): 检索并移除此双端队列的第一个元素，如果此双端队列为空，则阻塞直到元素可用。
• peek(): 检索但不移除此双端队列的第一个元素，如果此双端队列为空，则返回 null。
• remove(): 检索并移除此双端队列的第一个元素，如果此双端队列为空，则抛出异常。
• contains(Object o): 如果此双端队列包含指定的元素，则返回 true。
• offer(E e, long timeout, TimeUnit unit): 将指定的元素插入到此双端队列的末尾，在指定的等待时间内等待空间变得可用。
• toString(): 返回此双端队列的字符串表示形式。
• unlinkFirst(): 移除并返回此双端队列的第一个元素。
• offerLast(E e, long timeout, TimeUnit unit): 将指定的元素插入到此双端队列的末尾，在指定的等待时间内等待空间变得可用。
• take(): 检索并移除此双端队列的第一个元素，如果此双端队列为空，则阻塞直到元素可用。
• pollFirst(long timeout, TimeUnit unit): 检索并移除此双端队列的第一个元素，如果在指定的等待时间内此双端队列没有变为非空，则返回 null。
• size(): 返回此双端队列中的元素数量。
• push(E e): 将指定的元素插入到此双端队列的开头。
• add(E e): 将指定的元素插入到此双端队列的末尾。
• unlink(Node<E> x): 从链表中断开节点 x。
• pollFirst(): 检索并移除此双端队列的第一个元素，如果此双端队列为空，则返回 null。
• poll(): 检索并移除此双端队列的第一个元素，如果此双端队列为空，则返回 null。
• takeLast(): 检索并移除此双端队列的最后一个元素，如果此双端队列为空，则阻塞直到元素可用。
• iterator(): 返回在此双端队列上按正确顺序进行迭代的迭代器。
• linkLast(Node<E> node): 将节点链接到此双端队列的末尾。
• offerFirst(E e): 将指定的元素插入到此双端队列的开头。
• offer(E e): 将指定的元素插入到此双端队列的末尾。
• descendingIterator(): 返回在此双端队列上按逆序进行迭代的迭代器。
• offerLast(E e): 将指定的元素插入到此双端队列的末尾。
• spliterator(): 返回与此双端队列相关的元素的分割迭代器。
• addFirst(E e): 将指定的元素插入到此双端队列的开头。
• removeLast(): 检索并移除此双端队列的最后一个元素，如果此双端队列为空，则抛出异常。
• toArray(T[] a): 返回一个包含此双端队列所有元素的数组；返回数组的运行时类型是指定数组的类型。
• peekLast(): 检索但不移除此双端队列的最后一个元素，如果此双端队列为空，则返回 null。
• pop(): 检索并移除此双端队列的第一个元素，如果此双端队列为空，则抛出异常。
• linkFirst(Node<E> node): 将节点链接到此双端队列的开头。
• clear(): 清空此双端队列。
• readObject(ObjectInputStream s): 从指定的 ObjectInputStream 读取内容，重构此双端队列。
• getFirst(): 检索但不移除此双端队列的第一个元素，如果此双端队列为空，则抛出异常。
• putFirst(E e): 将指定的元素插入到此双端队列的开头。
• removeFirst(): 检索并移除此双端队列的第一个元素，如果此双端队列为空，则抛出异常。
• getLast(): 检索但不移除此双端队列的最后一个元素，如果此双端队列为空，则抛出异常。
• offerFirst(E e, long timeout, TimeUnit unit): 将指定的元素插入到此双端队列的开头，在指定的等待时间内等待空间变得可用。
• addLast(E e): 将指定的元素插入到此双端队列的末尾。
• poll(long timeout, TimeUnit unit): 检索并移除此双端队列的第一个元素，如果在指定的等待时间内此双端队列没有变为非空，则返回 null。
• toArray(): 返回一个包含此双端队列所有元素的数组。

LinkedTransferQueue

LinkedTransferQueue 是 Java 并发包 java.util.concurrent 中的一个类，它是一个基于链表的无界阻塞队列。它实现了 BlockingQueue 接口，并提供了额外的方法来支持多生产者、多消费者的场景。

类方法如下：

• firstOfMode(boolean): 返回队列中第一个具有指定模式的节点。
• size(): 返回队列中的元素数量。
• readObject(ObjectInputStream): 从输入流中读取对象并恢复队列的状态。
• casTail(Node, Node): 使用CAS操作尝试更新队列尾部节点。
• firstDataItem(): 返回队列中的第一个元素，但不移除它。
• countOfMode(boolean): 返回队列中具有指定模式的节点数量。
• poll(): 检索并移除此队列的头部，如果此队列为空，则返回 null。
• hasWaitingConsumer(): 如果存在等待获取元素的消费者，则返回 true。
• unsplice(Node?, Node): 将一个节点从队列中断开连接。
• drainTo(Collection<E>, int): 将队列中最多指定数量的元素移动到给定集合中。
• offer(E): 将指定的元素插入到此队列中。
• remove(Object): 从此队列中移除指定元素的单个实例（如果存在）。
• iterator(): 返回在此队列中的元素上进行迭代的迭代器。
• add(E): 将指定的元素插入到此队列中。
• spinsFor(Node?, boolean): 在等待条件成立时自旋的次数。
• tryTransfer(E, long, TimeUnit): 尝试将指定的元素传输到此队列中，如果在指定的时间内无法完成，则返回 false。
• findAndRemove(Object?): 查找并移除此队列中的指定元素（如果存在）。
• xfer(E, boolean, int, long): 尝试将指定的元素传输到此队列中，如果在指定的时间内无法完成，则返回 null。
• awaitMatch(Node, Node?, E, boolean, long): 等待匹配的元素出现，如果在指定的时间内无法完成，则返回 null。
• casSweepVotes(int, int): 使用CAS操作尝试更新清理投票计数。
• spliterator(): 返回对此队列中的元素进行分割的Spliterator。
• contains(Object): 如果此队列包含指定的元素，则返回 true。
• take(): 检索并移除此队列的头部，如果此队列为空，则阻塞。
• writeObject(ObjectOutputStream): 将此队列的内容写入 ObjectOutputStream。
• put(E): 将指定的元素插入到此队列中。
• tryAppend(Node, boolean): 尝试将指定的节点附加到此队列中。
• succ(Node): 返回给定节点的后继节点。
• firstDataNode(): 返回队列中的第一个数据节点。
• transfer(E): 将指定的元素传输到此队列中。
• sweep(): 清理队列中的无效节点。
• getWaitingConsumerCount(): 返回等待获取元素的消费者数量。
• tryTransfer(E): 尝试将指定的元素传输到此队列中，如果无法完成，则返回 false。
• casHead(Node, Node): 使用CAS操作尝试更新队列头部节点。
• offer(E, long, TimeUnit): 将指定的元素插入到此队列中，如果在指定的时间内无法完成，则返回 false。
• poll(long, TimeUnit): 检索并移除此队列的头部，如果此队列为空，则在指定的时间内阻塞。
• cast(Object): 将对象转换为 E 类型。
• peek(): 检索但不移除此队列的头部，如果此队列为空，则返回 null。
• drainTo(Collection<E>): 将队列中的所有元素移动到给定集合中。
• isEmpty(): 如果此队列不包含任何元素，则返回 true。
• remainingCapacity(): 返回此队列可以无阻塞地接受的元素数量。

PriorityBlockingQueue

PriorityBlockingQueue 是 Java 并发包 java.util.concurrent 中的一个类，它是一个基于优先级的无界阻塞队列。它实现了 BlockingQueue 接口，并提供了额外的方法来支持多生产者、多消费者的场景。

类方法如下：

• drainTo(Collection<E>): 将队列中的元素移动到指定的集合中，并返回实际移动的元素数量。
• remove(Object): 从队列中移除指定元素的单个实例（如果存在）。
• removeEQ(Object): 从队列中移除等于指定元素的所有实例。
• dequeue(): 检索并移除此队列的头部，如果此队列为空，则抛出异常。
• heapify(): 重新调整堆结构以保持堆的性质。
• spliterator(): 返回对此队列中的元素进行分割的Spliterator。
• drainTo(Collection<E>, int): 将队列中最多指定数量的元素移动到给定集合中。
• writeObject(ObjectOutputStream): 将此队列的内容写入 ObjectOutputStream。
• siftUpComparable(int, T, Object[]): 使用比较器向上调整堆。
• iterator(): 返回在此队列中的元素上进行迭代的迭代器。
• toString(): 返回此队列的字符串表示形式。
• offer(E): 将指定的元素插入到此队列中。
• remainingCapacity(): 返回此队列可以无阻塞地接受的元素数量。
• toArray(T[]): 返回一个包含此队列所有元素的数组。
• comparator(): 返回与此队列关联的比较器。
• add(E): 将指定的元素插入到此队列中。
• take(): 检索并移除此队列的头部，如果此队列为空，则阻塞。
• offer(E, long, TimeUnit): 将指定的元素插入到此队列中，如果在指定的时间内无法完成，则返回 false。
• siftDownComparable(int, T, Object[], int): 使用比较器向下调整堆。
• poll(long, TimeUnit): 检索并移除此队列的头部，如果此队列为空，则在指定的时间内阻塞。
• size(): 返回队列中的元素数量。
• readObject(ObjectInputStream): 从输入流中读取对象并恢复队列的状态。
• toArray(): 返回一个包含此队列所有元素的数组。
• clear(): 清空此队列。
• poll(): 检索并移除此队列的头部，如果此队列为空，则返回 null。
• removeAt(int): 从队列中移除指定索引处的元素。
• put(E): 将指定的元素插入到此队列中。
• peek(): 检索但不移除此队列的头部，如果此队列为空，则返回 null。
• siftUpUsingComparator(int, T, Object[], Comparator<T>): 使用比较器向上调整堆。
• contains(Object): 如果此队列包含指定的元素，则返回 true。
• tryGrow(Object[], int): 尝试增加数组的大小。
• siftDownUsingComparator(int, T, Object[], int, Comparator<T>): 使用比较器向下调整堆。
• indexOf(Object?): 返回此队列中指定元素的索引，如果不存在，则返回 -1。