Queue源码
public interface Queue<E> extends Collection<E> {
/**
* Inserts the specified element into this queue if it is possible to do so
* immediately without violating capacity restrictions, returning
* {@code true} upon success and throwing an {@code IllegalStateException}
* if no space is currently available.
*
* @param e the element to add
* @return {@code true} (as specified by {@link Collection#add})
* @throws IllegalStateException if the element cannot be added at this
* time due to capacity restrictions
* @throws ClassCastException if the class of the specified element
* prevents it from being added to this queue
* @throws NullPointerException if the specified element is null and
* this queue does not permit null elements
* @throws IllegalArgumentException if some property of this element
* prevents it from being added to this queue
*/
boolean add(E e);
/**
* Inserts the specified element into this queue if it is possible to do
* so immediately without violating capacity restrictions.
* When using a capacity-restricted queue, this method is generally
* preferable to {@link #add}, which can fail to insert an element only
* by throwing an exception.
*
* @param e the element to add
* @return {@code true} if the element was added to this queue, else
* {@code false}
* @throws ClassCastException if the class of the specified element
* prevents it from being added to this queue
* @throws NullPointerException if the specified element is null and
* this queue does not permit null elements
* @throws IllegalArgumentException if some property of this element
* prevents it from being added to this queue
*/
boolean offer(E e);
/**
* Retrieves and removes the head of this queue. This method differs
* from {@link #poll poll} only in that it throws an exception if this
* queue is empty.
*
* @return the head of this queue
* @throws NoSuchElementException if this queue is empty
*/
E remove();
/**
* Retrieves and removes the head of this queue,
* or returns {@code null} if this queue is empty.
*
* @return the head of this queue, or {@code null} if this queue is empty
*/
E poll();
/**
* Retrieves, but does not remove, the head of this queue. This method
* differs from {@link #peek peek} only in that it throws an exception
* if this queue is empty.
*
* @return the head of this queue
* @throws NoSuchElementException if this queue is empty
*/
E element();
/**
* Retrieves, but does not remove, the head of this queue,
* or returns {@code null} if this queue is empty.
*
* @return the head of this queue, or {@code null} if this queue is empty
*/
E peek();
}Queue接口的方法定义
- add(E e):添加一个元素，添加成功返回true, 如果队列满了，就会抛出异常
- offer(E e):添加一个元素，添加成功返回true, 如果队列满了，返回false
- remove():返回并删除队首元素，队列为空则抛出异常
- poll():返回并删除队首元素，队列为空则返回null
- element():返回队首元素，但不移除，队列为空则抛出异常
- peek():获取队首元素，但不移除，队列为空则返回null
BlockingQueue的入队出队操作
入队
- offer(E e)：如果队列没满，返回true，如果队列已满，返回false（不阻塞）
- offer(E e, long timeout, TimeUnit unit)：设置阻塞时间，如果队列已满，则进行阻塞。超过阻塞时间，则返回false
- put(E e)：队列没满的时候是正常的插入，如果队列已满，则阻塞，直至队列空出位置
出队
- poll()：如果有数据，出队，如果没有数据，返回null （不阻塞）
- poll(long timeout, TimeUnit unit)：设置阻塞时间，如果没有数据，则阻塞，超过阻塞时间，则返回null
- take()：队列里有数据会正常取出数据并删除；但是如果队列里无数据，则阻塞，直到队列里有数据
阻塞队列特性
阻塞功能使得生产者和消费者两端的能力得以平衡，当有任何一端速度过快时，阻塞队列便会把过快的速度给降下来，其最主要的两个方法是put和take。
put
向队列中插入元素，如果队列没有满，就像普通元素的插入一样，若队列满了，则会阻塞入队线程，直到队列中有空闲的位置，也就是其中一个任务被取出后，队列就会解除阻塞的状态。
take
从队列中取一个元素，是先取头结点的元素的，同样的，若队列中没有元素可以取，则会阻塞消费元素的线程，直到队列中插入了新元素，插入的同时也会解除阻塞的状态。
队列容量
分为有界和无界两种
顾名思义，有界队列指的是在初始化队列的时候就会指定队列的容量，而无界队列则是指容量非常大可以容纳大量的元素，例如LinkBlockQueue的队列设置的容量就是Integer.Max_Value,近乎可以看成是一个无界的队列。
应用场景
BlockQueue是线程安全的，因此在大部分的场景下，我们可以用它来解决业务对应下的线程并发安全。因为线程中使用的队列是安全的，且生产者和消费者都是多线程的，一定程度上降低了开发的难度和工作量。同时，使用队列的好处还在于耦合性低，业务的实现只需要关注从队列中取任务去执行，而不用关注具体的业务处理逻辑，在一定方向上起到了隔离的作用。
常见的阻塞队列
| 类型 | 描述 |
| ArrayBlockingQueue | 基于数组结构实现的一个有界阻塞队列 |
| LinkedBlockingQueue | 基于链表结构实现的一个有界阻塞队列 |
| PriorityBlockingQueue | 支持按优先级排序的无界阻塞队列 |
| DelayQueue | 基于优先级队列（PriorityBlockingQueue）实现的无界阻塞队列 |
| SynchronousQueue | 不存储元素的阻塞队列 |
| LinkedTransferQueue | 基于链表结构实现的一个无界阻塞队列 |
| LinkedBlockingDeque | 基于链表结构实现的一个双端阻塞队列 |
ArrayBlockingQueue
特性
ArrayBlockingQueue是最典型的有界阻塞队列，其内部是用数组存储元素的，初始化时需要指定容量大小，利用 ReentrantLock 实现线程安全。
使用场景
在生产者-消费者模型中使用时，如果生产速度和消费速度基本匹配的情况下，使用ArrayBlockingQueue是个不错选择；当如果生产速度远远大于消费速度，则会导致队列填满，大量生产线程被阻塞。
实现机制
使用独占锁ReentrantLock实现线程安全，入队和出队的操作都是一把锁，意味着同一时间只能有一个线程工作，在高并发的场景下，效率是很低的。
使用
final ReentrantLock lock;
/** Condition for waiting takes */
private final Condition notEmpty;
/** Condition for waiting puts */
private final Condition notFull;原理
入队put
- 先检查队列是否为空
- 加锁
- 判断是否队列已满，若是，则进行notFull阻塞
- 否则，入队
- 最后finally解锁
public void put(E e) throws InterruptedException {
checkNotNull(e);
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();
try {
while (count == items.length)
notFull.await();
enqueue(e);
} finally {
lock.unlock();
}
}- 入参元素赋值给putIndex下标位置
- 判断是否最后一个下标，是将putIndex指向队首
- 唤醒notEmpty出队的阻塞
private void enqueue(E x) {
// assert lock.getHoldCount() == 1;
// assert items[putIndex] == null;
final Object[] items = this.items;
items[putIndex] = x;
if (++putIndex == items.length)
putIndex = 0;
count++;
notEmpty.signal();
}出队take
- 加锁
- 判断队列元素是否为0，是notEmpty阻塞
- 出队
- 解锁
public E take() throws InterruptedException {
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();
try {
while (count == 0)
notEmpty.await();
return dequeue();
} finally {
lock.unlock();
}
}- 出队takeIndex的元素，并将该位置元素设置为null
- 判断是否到了队尾，是则移动takeIndex到队首
- 唤醒notFull
//上述出队操作
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;
if (++takeIndex == items.length)
takeIndex = 0;
count--;
if (itrs != null)
itrs.elementDequeued();
notFull.signal();
return x;
}LinkedBlockingQueue
特性
以链表作为数据结构的有界队列。
构造器
若不指定队列的容量，其容量为Integer.MAX_VALUE，几乎无界
public LinkedBlockingQueue() {
this(Integer.MAX_VALUE);
}
/**
* Creates a {@code LinkedBlockingQueue} with the given (fixed) capacity.
*
* @param capacity the capacity of this queue
* @throws IllegalArgumentException if {@code capacity} is not greater
* than zero
*/
public LinkedBlockingQueue(int capacity) {
if (capacity <= 0) throw new IllegalArgumentException();
this.capacity = capacity;
last = head = new Node<E>(null);
}LinkedBlockingQueue与ArrayBlockingQueue对比
LinkedBlockingQueue是一个阻塞队列，内部由两个ReentrantLock来实现出入队列的线程安全，由各自的Condition对象的await和signal来实现等待和唤醒功能。它和ArrayBlockingQueue的不同点在于：
- 队列大小有所不同，ArrayBlockingQueue是有界的初始化必须指定大小，而LinkedBlockingQueue可以是有界的也可以是无界的(Integer.MAX_VALUE)，对于后者而言，当添加速度大于移除速度时，在无界的情况下，可能会造成内存溢出等问题。
- 数据存储容器不同，ArrayBlockingQueue采用的是数组作为数据存储容器，而LinkedBlockingQueue采用的则是以Node节点作为连接对象的链表。
- 由于ArrayBlockingQueue采用的是数组的存储容器，因此在插入或删除元素时不会产生或销毁任何额外的对象实例，而LinkedBlockingQueue则会生成一个额外的Node对象。这可能在长时间内需要高效并发地处理大批量数据的时，对于GC可能存在较大影响。
- 两者的实现队列添加或移除的锁不一样，ArrayBlockingQueue实现的队列中的锁是没有分离的，即添加操作和移除操作采用的同一个ReenterLock锁，而LinkedBlockingQueue实现的队列中的锁是分离的，其添加采用的是putLock，移除采用的则是takeLock，这样能大大提高队列的吞吐量，也意味着在高并发的情况下生产者和消费者可以并行地操作队列中的数据，以此来提高整个队列的并发性能。
SynchronousQueue
特性
是一个容量为0的无缓冲队列，底层使用链表作为数据基础，生产者的put入队操作必须等待消费者的出队操作take之后才能进行，直接在两个线程之间进行消息的传递。它的出队都会先阻塞，直到有生产者put入队才能出队，相同的，入队操作也会阻塞，要等到有消费者进行消费。
应用场景
适合做传递性场景的交换工作，另一个场景则是在线程池中使用，当有任务来但不确定数量，又要快速处理的时候，可以使用该队列，例如Executors.newCachedThreadPool()使用的就是，当有新的任务提交，会创建新线程去执行，若有空闲线程则会重复利用。
实现机制
通过CAS+自旋的操作来执行入队和出队的操作，也有公平和非公平两种实现方式
public SynchronousQueue() {
this(false);
}
/**
* Creates a {@code SynchronousQueue} with the specified fairness policy.
*
* @param fair if true, waiting threads contend in FIFO order for
* access; otherwise the order is unspecified.
*/
public SynchronousQueue(boolean fair) {
transferer = fair ? new TransferQueue<E>() : new TransferStack<E>();
}入队put
public void put(E e) throws InterruptedException {
if (e == null) throw new NullPointerException();
if (transferer.transfer(e, false, 0) == null) {
Thread.interrupted();
throw new InterruptedException();
}
}通过CAS+自旋获取锁
出队take
public E take() throws InterruptedException {
E e = transferer.transfer(null, false, 0);
if (e != null)
return e;
Thread.interrupted();
throw new InterruptedException();
}PriorityBlockingQueue
无界的基于数组的有优先级的阻塞队列，数组长度默认11，但是可以扩容，默认情况下是升序排序，也可以通过Compare来构造指定排序方式，队列中的每一个元素都有优先级，出队时，优先级高的先出队。
应用场景
适合有优先级的业务，例如，商场购物，VIP客户比普通客户优惠力度更大，或可以插队先办理业务。
使用
PriorityBlockingQueue<Integer> queue=new PriorityBlockingQueue<Integer>(5);
如何设计优先级
普通数组
- 执行插入操作时，直接将元素插入到数组末端，需要的成本为O(1),
- 获取优先级最高元素，我们需要遍历整个线性队列，匹配出优先级最高元素，需要的成本为o(n)
- 删除优先级最高元素，我们需要两个步骤，第一找出优先级最高元素，第二步删除优先级最高元素，然后将后面的元素依次迁移，填补空缺，需要的成本为O(n)+O(n)=O(n)
有序向量
- 获取优先级最高元素，O(1)
- 删除优先级最高元素，O(1)
- 插入一个元素，需要两个步骤，第一步我们需要找出要插的位置，这里我们可以使用二分查找，成本为O(logn)，第二步是插入元素之后，将其所有后继进行后移操作，成本为O(n)，所有总成本为O(logn)+O(n)=O(n)
二叉堆
完全二叉树：除了最后一行，其他行都满的二叉树，而且最后一行所有叶子节点都从左向右开始排序。
二叉堆：完全二叉树的基础上，加以一定的条件约束的一种特殊的二叉树。根据约束条件的不同，二叉堆又可以分为两个类型：大顶堆和小顶堆。
大顶堆（最大堆）：父结点的键值总是大于或等于任何一个子节点的键值；
小顶堆（最小堆）：父结点的键值总是小于或等于任何一个子节点的键值。
节点下标计算公式
parent(t) = (t-1)>>>1 相当于（t-1)/2
left(t) = t<<1+1 相当于t*2+1
right(t) = t<<1+2 相当于t*2+1
小结：小顶堆，入队上浮，出队下沉
DelayQueue
是一个支持延时获取元素的阻塞队列， 内部采用优先队列 PriorityQueue 存储元素，同时元素必须实现 Delayed 接口；在创建元素时可以指定多久才可以从队列中获取当前元素，只有在延迟期满时才能从队列中提取元素。延迟队列的特点是：不是先进先出，而是会按照延迟时间的长短来排序，下一个即将执行的任务会排到队列的最前面。它是无界队列，放入的元素必须实现 Delayed 接口，而 Delayed 接口又继承了Comparable 接口，所以自然就拥有了比较和排序的能力
入队put
public boolean offer(E e) {
final ReentrantLock lock = this.lock;
lock.lock();
try {
q.offer(e);
if (q.peek() == e) {
leader = null;
available.signal();
}
return true;
} finally {
lock.unlock();
}
}出队take
public E take() throws InterruptedException {
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();
try {
for (;;) {
E first = q.peek();
if (first == null)
available.await();
else {
long delay = first.getDelay(NANOSECONDS);
if (delay <= 0)
return q.poll();
first = null; // don't retain ref while waiting
if (leader != null)
available.await();
else {
Thread thisThread = Thread.currentThread();
leader = thisThread;
try {
available.awaitNanos(delay);
} finally {
if (leader == thisThread)
leader = null;
}
}
}
}
} finally {
if (leader == null && q.peek() != null)
available.signal();
lock.unlock();
}
}流程
- 当获取元素时，先获取到锁对象。
- 获取最早过期的元素，但是并不从队列中弹出元素。
- 最早过期元素是否为空，如果为空则直接让当前线程无限期等待状态，并且让出当前锁对象。
- 如果最早过期的元素不为空
- 获取最早过期元素的剩余过期时间，如果已经过期则直接返回当前元素
- 如果没有过期，也就是说剩余时间还存在，则先获取Leader对象，如果Leader已经有线程在处理，则当前线程进行无限期等待，如果Leader为空，则首先将Leader设置为当前线程，并且让当前线程等待剩余时间。
- 最后将Leader线程设置为空
- 如果Leader已经为空，并且队列有内容则唤醒一个等待的队列。
选择阻塞队列的原则
线程池选择阻塞队列
线程池有很多种，不同种类的线程池会根据自己的特点，来选择适合自己的阻塞队列。
- FixedThreadPool（SingleThreadExecutor 同理）选取的是 LinkedBlockingQueue
- CachedThreadPool 选取的是 SynchronousQueue
- ScheduledThreadPool（SingleThreadScheduledExecutor同理）选取的是延迟队列
选择策略
通常我们可以从以下 5 个角度考虑，来选择合适的阻塞队列：
功能
需要考虑的就是功能层面，比如是否需要阻塞队列帮我们排序，如优先级排序、延迟执行等。如果有这个需要，我们就必须选择类似于 PriorityBlockingQueue 之类的有排序能力的阻塞队列。
容量
需要考虑的是容量，或者说是否有存储的要求，还是只需要“直接传递”。在考虑这一点的时候，我们知道前面介绍的那几种阻塞队列，有的是容量固定的，如 ArrayBlockingQueue；有的默认是容量无限的，如 LinkedBlockingQueue；而有的里面没有任何容量，如 SynchronousQueue；而对于 DelayQueue 而言，它的容量固定就是Integer.MAX_VALUE。所以不同阻塞队列的容量是千差万别的，我们需要根据任务数量来推算出合适的容量，从而去选取合适的 BlockingQueue。
能否扩容
需要考虑的是能否扩容。因为有时我们并不能在初始的时候很好的准确估计队列的大小，因为业务可能有高峰期、低谷期。如果一开始就固定一个容量，可能无法应对所有的情况，也是不合适的，有可能需要动态扩容。如果我们需要动态扩容的话，那么就不能选择ArrayBlockingQueue ，因为它的容量在创建时就确定了，无法扩容。相反，PriorityBlockingQueue 即使在指定了初始容量之后，后续如果有需要，也可以自动扩容。所以我们可以根据是否需要扩容来选取合适的队列。
内存结构
需要考虑的点就是内存结构。我们分析过 ArrayBlockingQueue 的源码，看到了它的内部结构是“数组”的形式。和它不同的是，LinkedBlockingQueue 的内部是用链表实现的，所以这里就需要我们考虑到，ArrayBlockingQueue 没有链表所需要的“节点”，空间利用率更高。所以如果我们对性能有要求可以从内存的结构角度去考虑这个问题。
性能
从性能的角度去考虑。比如 LinkedBlockingQueue 由于拥有两把锁，它的操作粒度更细，在并发程度高的时候，相对于只有一把锁的 ArrayBlockingQueue 性能会更好。另外，SynchronousQueue 性能往往优于其他实现，因为它只需要“直接传递”，而不需要存储的过程。如果我们的场景需要直接传递的话，可以优先考虑 SynchronousQueue。
2794
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
