阻塞队列
1. 什么是阻塞队列？
阻塞队列（BlockingQueue） 是一个支持两个附加操作的队列。这两个附加的操作是：在队列为空时，获取元素的线程会等待队列变为非空。当队列满时，存储元素的线程会等待队列可用。
阻塞队列常用于生产者和消费者的场景，生产者是往队列里添加元素的线程，消费者是从队列里拿元素的线程。阻塞队列就是生产者存放元素的容器，而消费者也只从容器里拿元素。
2. Java里的阻塞队列
JDK7提供了7个阻塞队列。分别是
- ArrayBlockingQueue ： 一个由数组结构组成的有界阻塞队列。
- LinkedBlockingQueue ： 一个由链表结构组成的有界阻塞队列。
- PriorityBlockingQueue ： 一个支持优先级排序的无界阻塞队列。
- DelayQueue： 一个使用优先级队列实现的无界阻塞队列。
- SynchronousQueue： 一个不存储元素的阻塞队列。
- LinkedTransferQueue： 一个由链表结构组成的无界阻塞队列。
- LinkedBlockingDeque： 一个由链表结构组成的双向阻塞队列。
BlockingQueue接口 与 BlockingDeque 接口
JDK提供的阻塞队列中，LinkedBlockingDeque 是一个 Deque（双向的队列），其实现的接口是 BlockingDeque；其余6个阻塞队列则是 Queue（单向队列），实现的接口是 BlockingQueue。
对于 BlockingQueue 的阻塞队列提供了四种处理方法:
| 方法描述 | 抛出异常 | 返回特殊的值 | 一直阻塞 | 超时退出 |
|---|---|---|---|---|
| 插入数据 | add(e) | offer(e) | put(e) | offer(e,time,unit) |
| 获取并移除队列的头 | remove() | poll() | take() | poll(time,unit) |
| 获取但不移除队列的头（查询） | element() | peek() | 不可用 | 不可用 |
- 抛出异常： 是指当阻塞队列满时候，再往队列里插入元素，会抛出IllegalStateException(“Queue full”)异常。当队列为空时，从队列里获取元素时会抛出NoSuchElementEx·ception异常 。
- 返回特殊值： 插入方法会返回是否成功，成功则返回true。移除方法，则是从队列里拿出一个元素，如果没有则返回null
- 一直阻塞： 当阻塞队列满时，如果生产者线程往队列里put元素，队列会一直阻塞生产者线程，直到拿到数据，或者响应中断退出。当队列空时，消费者线程试图从队列里take元素，队列也会阻塞消费者线程，直到队列可用。
- 超时退出： 当阻塞队列满时，队列会阻塞生产者线程一段时间，如果超过一定的时间，生产者线程就会退出。
抛出异常 与 返回特殊值 方法的实现是一样的，只不过对失败的操作的处理不一样！通过 AbstractQueue 的源码可以发现，add(e),remove(),element() 都是分别基于 offer()，poll()，peek() 实现的
1 public boolean add(E arg0) { 2 if (this.offer(arg0)) { 3 return true; 4 } else { 5 throw new IllegalStateException("Queue full"); 6 } 7 } 8 9 public E remove() { 10 Object arg0 = this.poll(); 11 if (arg0 != null) { 12 return arg0; 13 } else { 14 throw new NoSuchElementException(); 15 } 16 } 17 18 public E element() { 19 Object arg0 = this.peek(); 20 if (arg0 != null) { 21 return arg0; 22 } else { 23 throw new NoSuchElementException(); 24 } 25 }
JDK 文档提到的几点：
- BlockingQueue 不接受 null 元素。试图 add、put 或 offer 一个 null 元素时，某些实现会抛出 NullPointerException。null 被用作指示 poll 操作失败的警戒值。
- BlockingQueue 可以是限定容量的。它在任意给定时间都可以有一个 remainingCapacity，超出此容量，便无法无阻塞地 put 附加元素。没有任何内部容量约束的 BlockingQueue 总是报告 Integer.MAX_VALUE 的剩余容量。
- BlockingQueue 实现主要用于生产者-使用者队列，但它另外还支持 Collection 接口。因此，举例来说，使用 remove(x) 从队列中移除任意一个元素是有可能的。然而，这种操作通常不 会有效执行，只能有计划地偶尔使用，比如在取消排队信息时。
- BlockingQueue 实现是线程安全的。所有排队方法都可以使用内部锁或其他形式的并发控制来自动达到它们的目的。然而，大量的 Collection 操作（addAll、containsAll、retainAll 和 removeAll，这些方法尽可能地少使用）没有 必要自动执行，除非在实现中特别说明。因此，举例来说，在只添加了 c 中的一些元素后，addAll(c) 有可能失败（抛出一个异常）。
对于 BlockingDeque 的双向队列也提供了四种形式的方法
第一个元素（头部）
| 方法描述 | 抛出异常 | 返回特殊的值 | 一直阻塞 | 超时退出 |
|---|---|---|---|---|
| 插入数据 | addFirst(e) | offerFirst(e) | putFirst(e) | offerFirst(e, time, unit) |
| 获取并移除队列的头 | removeFirst() | pollFirst() | takeFirst() | pollFirst(time, unit) |
| 获取但不移除队列的头 | getFirst() | peekFirst() | 不适用 | 不适用 |
最后一个元素（尾部）
| 方法描述 | 抛出异常 | 返回特殊的值 | 一直阻塞 | 超时退出 |
|---|---|---|---|---|
| 插入数据 | addLast(e) | offerLast(e) | putLast(e) | offerLast(e, time, unit) |
| 获取并移除队列的头 | removeLast() | pollLast() | takeLast() | pollLast(time, unit) |
| 获取但不移除队列的头 | getLast() | peekLast() | 不适用 | 不适用 |
像所有 BlockingQueue 一样，BlockingDeque 是线程安全的，但不允许 null 元素，并且可能有（也可能没有）容量限制。
BlockingDeque 接口继承扩展了 BlockingQueue 接口，对于 继承自 BlockingQueue 的方法，除了插入方法（add、poll、offer方法，是插入的队列的尾部），其他方法，操作的都是队列的头部（第一个元素）。
常用阻塞队列的详细介绍
1. ArrayBlockingQueue
ArrayBlockingQueue是一个用数组实现的 有界阻塞队列。 此队列按照先进先出（FIFO）的原则对元素进行排序。
默认情况下不保证访问者公平地访问队列 ，所谓公平访问队列是指阻塞的线程，可按照阻塞的先后顺序访问队列。非公平性是对先等待的线程是不公平的，当队列可用时，阻塞的线程都可以竞争访问队列的资格。
为了保证公平性，通常会降低吞吐量。
ArrayBlockingQueue fairQueue = new ArrayBlockingQueue(1000,true);
访问者的公平性是使用可重入锁实现的 ，代码如下：
1 public ArrayBlockingQueue(int capacity, boolean fair) { 2 if (capacity <= 0) 3 throw new IllegalArgumentException(); 4 this.items = new Object[capacity]; 5 lock = new ReentrantLock(fair); 6 notEmpty = lock.newCondition(); 7 notFull = lock.newCondition(); 8 }
2. LinkedBlockingQueue
LinkedBlockingQueue是一个用链表实现的无界阻塞队列。此队列的默认和最大长度为Integer.MAX_VALUE。 此队列按照先进先出的原则对元素进行排序。
3. PriorityBlockingQueue
PriorityBlockingQueue是一个支持优先级的无界队列（虽然此队列逻辑上是无界的，但是资源被耗尽时试图执行 add 操作也将失败，导致 OutOfMemoryError）。默认情况下元素采取自然顺序排列（每个元素都必须实现 Comparable 接口），也可以通过比较器comparator来指定元素的排序规则。元素按照升序排列.
底层采用堆（数组）结构，大顶堆或小顶堆，入堆上浮，出队下沉操作维持堆结构。
其iterator() 方法中提供的迭代器并不保证以特定的顺序遍历 PriorityBlockingQueue 的元素。如果需要有序地进行遍历，则应考虑使用 Arrays.sort(pq.toArray())。此外，可以使用方法 drainTo 按优先级顺序移除全部或部分元素，并将它们放在另一个 collection 中。
在此类上进行的操作不保证具有同等优先级的元素的顺序。 如果需要实施某一排序，那么可以定义自定义类或者比较器，比较器可使用修改键断开主优先级值之间的联系。例如，以下是应用先进先出 (first-in-first-out) 规则断开可比较元素之间联系的一个类。要使用该类，则需要插入一个新的 FIFOEntry(anEntry) 来替换普通的条目对象。
1 class FIFOEntry<E extends Comparable<? super E>> 2 implements Comparable<FIFOEntry<E>> { 3 final static AtomicLong seq = new AtomicLong(); 4 final long seqNum; 5 final E entry; 6 public FIFOEntry(E entry) { 7 seqNum = seq.getAndIncrement(); 8 this.entry = entry; 9 } 10 public E getEntry() { return entry; } 11 public int compareTo(FIFOEntry<E> other) { 12 int res = entry.compareTo(other.entry); 13 if (res == 0 && other.entry != this.entry) 14 res = (seqNum < other.seqNum ? -1 : 1); 15 return res; 16 } 17 }
4. DelayQueue
Delayed 元素的一个无界阻塞队列，只有在延迟期满时才能从中提取元素。注意 DelayQueue 的所有方法只能操作“到期的元素“，例如，poll()、remove()、size()等方法，都会忽略掉未到期的元素。
实现Delayed函数式接口：getDelay（TimeUnit unit）获得元素过期时间。
我们可以将DelayQueue运用在以下应用场景：
- 缓存系统的设计：可以用DelayQueue保存缓存元素的有效期，使用一个线程循环查询DelayQueue，一旦能从DelayQueue中获取元素时，表示缓存有效期到了。
- 定时任务调度。使用DelayQueue保存当天将会执行的任务和执行时间，一旦从DelayQueue中获取到任务就开始执行，从比如TimerQueue就是使用DelayQueue实现的。
DelayQueue 的实现是基于 PriorityQueue,是一个优先级队列，是以延时时间的长短进行排序的。所以，DelayQueue 需要知道每个元素的延时时间，而这个延时时间是由 Delayed 接口的 getDelay()方法获取的。所以， DelayQueue 的元素必须实现 Delay 接口；
1 //计算并返回延时时间 2 public long getDelay(TimeUnit unit) { 3 return unit.convert(time - now(), TimeUnit.NANOSECONDS); 4 }
延时队列的原理
延时队列的实现很简单，当消费者从队列里获取元素时，如果元素没有达到延时时间，就阻塞当前线程。
1 long delay = first.getDelay(TimeUnit.NANOSECONDS); 2 if (delay <= 0) 3 return q.poll(); 4 else if (leader != null) 5 available.await();
5. SynchronousQueue
一种阻塞队列，其中每个插入操作必须等待另一个线程的对应移除操作 ，反之亦然。
SynchronousQueue 的几个特点
- 同步队列没有任何内部容量，甚至连一个队列的容量都没有。 所以很多继承的方法就没有用了，（如 isEmpty()始终返回true,size()为0,包含contain、移除remove 都始终为false 等等)。或者说，真正有意义的只有以下几个方法：获取并移除（poll()、poll(timeout，timeunit)、take()）、插入（offer()、offer(timeout,timeunit)、put()）;
- 适合于传递性设计，在这种设计中, 每一个put操作必须等待一个take操作，反之亦然 。（当然，如果用的是offer、poll的话，那么就不会阻塞等待）。SynchronousQueue可以看成是一个传球手，负责把生产者线程处理的数据直接传递给消费者线程。
- 支持可选的公平排序策略。 默认情况下不保证这种排序。但是，使用公平设置为 true 所构造的队列可保证线程以 FIFO 的顺序进行访问。
//设置公平性的构造方法 public SynchronousQueue(boolean fair) 创建一个具有指定公平策略的 SynchronousQueue。
6. LinkedTransferQueue
LinkedTransferQueue是一个由链表结构组成的 无界阻塞TransferQueue队列 。相对于其他阻塞队列LinkedTransferQueue多了tryTransfer和transfer方法。
transfer方法： 如果当前有消费者正在等待接收元素（消费者使用take()方法或带时间限制的poll()方法时），transfer方法可以把生产者传入的元素立刻transfer（传输）给消费者。如果没有消费者在等待接收元素，transfer方法会将元素存放在队列的tail节点，并等到该元素被消费者消费了才返回。transfer方法的关键代码如下：
Node pred = tryAppend(s, haveData); return awaitMatch(s, pred, e, (how == TIMED), nanos);
tryTransfer方法： 则是用来试探下生产者传入的元素是否能直接传给消费者。如果没有消费者等待接收元素，则返回false。和transfer方法的区别是tryTransfer方法无论消费者是否接收，方法立即返回。而transfer方法是必须等到消费者消费了才返回。
对于带有时间限制的 tryTransfer(E e, long timeout, TimeUnit unit)方法 ，则是试图把生产者传入的元素直接传给消费者，但是如果没有消费者消费该元素则等待指定的时间再返回，如果超时还没消费元素，则返回false，如果在超时时间内消费了元素，则返回true。
原理：
LinkedTransferQueue采用的一种预占模式。意思就是消费者线程取元素时，如果队列为空，那就生成一个节点（节点元素为null）入队，然后消费者线程park住，后面生产者线程入队时发现有一个元素为null的节点，生产者线程就不入队了，直接就将元素填充到该节点，唤醒该节点上park住线程，被唤醒的消费者线程拿货走人。
7. LinkedBlockingDeque
LinkedBlockingDeque是一个由链表结构组成的双向阻塞队列。所谓双向队列指的你可以从队列的两端插入和移出元素。 双端队列因为多了一个操作队列的入口，在多线程同时入队时，也就减少了一半的竞争。 相比其他的阻塞队列，LinkedBlockingDeque多了addFirst，addLast，offerFirst，offerLast，peekFirst，peekLast等方法。另外，插入方法add等同于addLast，移除方法remove等效于removeFirst。但是take方法却等同于takeFirst，不知道是不是Jdk的bug，使用时还是用带有First和Last后缀的方法更清楚。
和 LinkedBlockingQueue 一样，是有界的阻塞队列，默认长度以及最大长度是 Integer.MAX_VALUE。可在创建时，指定容量。
阻塞队列的实现原理
如果队列是空的，消费者会一直等待，当生产者添加元素时候，消费者是如何知道当前队列有元素的呢？如果让你来设计阻塞队列你会如何设计，让生产者和消费者能够高效率的进行通讯呢？让我们先来看看JDK是如何实现的。
使用通知模式实现。所谓通知模式，就是当生产者往满的队列里添加元素时会阻塞住生产者，当消费者消费了一个队列中的元素后，会通知生产者当前队列可用。通过查看JDK源码发现ArrayBlockingQueue使用了Condition来实现，代码如下
1 private final Condition notFull; 2 private final Condition notEmpty; 3 4 public ArrayBlockingQueue(int capacity, boolean fair) { 5 //省略其他代码 6 notEmpty = lock.newCondition(); 7 notFull = lock.newCondition(); 8 } 9 10 public void put(E e) throws InterruptedException { 11 checkNotNull(e); 12 final ReentrantLock lock = this.lock; 13 lock.lockInterruptibly(); 14 try { 15 while (count == items.length) 16 notFull.await(); 17 insert(e); 18 } finally { 19 lock.unlock(); 20 } 21 } 22 23 public E take() throws InterruptedException { 24 final ReentrantLock lock = this.lock; 25 lock.lockInterruptibly(); 26 try { 27 while (count == 0) 28 notEmpty.await(); 29 return extract(); 30 } finally { 31 lock.unlock(); 32 } 33 } 34 35 private void insert(E x) { 36 items[putIndex] = x; 37 putIndex = inc(putIndex); 38 ++count; 39 notEmpty.signal(); 40 }
当我们往队列里插入一个元素时，如果队列不可用，阻塞生产者主要通过LockSupport.park(this);来实现
1 public final void await() throws InterruptedException { 2 if (Thread.interrupted()) 3 throw new InterruptedException(); 4 Node node = addConditionWaiter(); 5 int savedState = fullyRelease(node); 6 int interruptMode = 0; 7 while (!isOnSyncQueue(node)) { 8 LockSupport.park(this); 9 if ((interruptMode = checkInterruptWhileWaiting(node)) != 0) 10 break; 11 } 12 if (acquireQueued(node, savedState) && interruptMode != THROW_IE) 13 interruptMode = REINTERRUPT; 14 if (node.nextWaiter != null) // clean up if cancelled 15 unlinkCancelledWaiters(); 16 if (interruptMode != 0) 17 18 reportInterruptAfterWait(interruptMode); 19 }
继续进入源码，发现调用setBlocker先保存下将要阻塞的线程，然后调用unsafe.park阻塞当前线程。
1 public static void park(Object blocker) { 2 Thread t = Thread.currentThread(); 3 setBlocker(t, blocker); 4 unsafe.park(false, 0L); 5 setBlocker(t, null); 6 }
park这个方法会阻塞当前线程，只有以下四种情况中的一种发生时，该方法才会返回。
- 与park对应的unpark执行或已经执行时。注意：已经执行是指unpark先执行，然后再执行的park。
- 线程被中断时。
- 如果参数中的time不是零，等待了指定的毫秒数时。
- 发生异常现象时。这些异常事先无法确定。
现在创建线程池，ThredPoolExecutor不是Executors；线程池结束shutdown（）会先等线程都执行完毕，
线程池shutdown（），shutdownNow（）会立即终止，在线程中抛出中止异常，catch语句中break终止；
线程池状态；
newCachedThreadPool 变长
阻塞队列使用SynchronousQueue
创建一个**可根据需要创建新线程**的线程池，但是在以前构造的线程可用时将**重用**它们。对于执行 很多短期异步任务的程序而言，这些线程池通常可提高程序性能。调用 execute 将重用以前构造的线程（如果线程可用）。如果现有线程没有可用的，则创建一个新线程并添加到池中。终止并从缓存中移除那些已有 60 秒钟未被使用的线程。因此，长时间保持空闲的线程池不会使用任何资源。
newFixedThreadPool 定长
阻塞队列使用linkedBlockingQueue
创建一个**可重用固定线程数**的线程池，以**共享的无界队列**方式来运行这些线程。在任意点，在大多数 nThreads 线程会处于处理任务的活动状态。如果在所有线程处于活动状态时提交附加任务， 则在有可用线程之前，附加任务将在队列中**等待**。如果在关闭前的执行期间由于失败而导致任何线程终止，那么一个新线程将代替它执行后续的任务（如果需要）。在某个线程被显式地关闭之前，池中的线程将一直存在。
newScheduledThreadPool 延时
创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。**延期、定期执行**
newSingleThreadExecutor 单一
阻塞队列使用linkedBlockingQueue
Executors.newSingleThreadExecutor()返回一个线程池（这个线程池只有一个线程）,这个线程 池可以在线程死后（或发生异常时）重新启动一个线程来替代原来的线程继续执行下去！
· 阿里巴巴 QwQ-32B真的超越了 DeepSeek R-1吗？
· 10年+ .NET Coder 心语 ── 封装的思维：从隐藏、稳定开始理解其本质意义
· 【设计模式】告别冗长if-else语句：使用策略模式优化代码结构
· 字符编码：从基础到乱码解决
· 提示词工程——AI应用必不可少的技术