七种阻塞队列
在前面我们接触的队列都是非阻塞队列，比如PriorityQueue、LinkedList（LinkedList是双向链表，它实现了Dequeue接口）。
使用非阻塞队列的时候有一个很大问题就是：它不会对当前线程产生阻塞，那么在面对类似消费者-生产者的模型时，就必须额外地实现同步策略以及线程间唤醒策略，这个实现起来就非常麻烦。但是有了阻塞队列就不一样了，它会对当前线程产生阻塞，比如一个线程从一个空的阻塞队列中取元素，此时线程会被阻塞直到阻塞队列中有了元素。当队列中有元素后，被阻塞的线程会自动被唤醒（不需要我们编写代码去唤醒）。这样提供了极大的方便性。
1.非阻塞队列中的几个主要方法：
add(E e):将元素e插入到队列末尾，如果插入成功，则返回true；如果插入失败（即队列已满），则会抛出异常；
remove()：移除队首元素，若移除成功，则返回true；如果移除失败（队列为空），则会抛出异常；
offer(E e)：将元素e插入到队列末尾，如果插入成功，则返回true；如果插入失败（即队列已满），则返回false；
poll()：移除并获取队首元素，若成功，则返回队首元素；否则返回null；
peek()：获取队首元素，若成功，则返回队首元素；否则返回null
对于非阻塞队列，一般情况下建议使用offer、poll和peek三个方法，不建议使用add和remove方法。因为使用offer、poll和peek三个方法可以通过返回值判断操作成功与否，而使用add和remove方法却不能达到这样的效果。注意，非阻塞队列中的方法都没有进行同步措施。
2.阻塞队列中的几个主要方法：
阻塞队列包括了非阻塞队列中的大部分方法，上面列举的5个方法在阻塞队列中都存在，但是要注意这5个方法在阻塞队列中都进行了同步措施。除此之外，阻塞队列提供了另外4个非常有用的方法：
put(E e)：put方法用来向队尾存入元素，如果队列满，则等待；
take()：take方法用来从队首取元素，如果队列为空，则等待；
offer(E e,long timeout, TimeUnit unit)：offer方法用来向队尾存入元素，如果队列满，则等待一定的时间，当时间期限达到时，如果还没有插入成功，则返回false；否则返回true；
poll(long timeout, TimeUnit unit)：poll方法用来从队首取元素，如果队列空，则等待一定的时间，当时间期限达到时，如果取到，则返回null；否则返回取得的元素；
- 抛出异常：当队列满时，如果再往队列里插入元素，会抛出IllegalStateException（"Queuefull"）异常。当队列空时，从队列里获取元素会抛出NoSuchElementException异常。
- 返回特殊值：当往队列插入元素时，会返回元素是否插入成功，成功返回true，失败返回false。如果是移除方法，则是从队列里取出一个元素，如果有就返回元素，没有则返回null。
- 一直阻塞：当阻塞队列满时，如果生产者线程往队列里put元素，队列会一直阻塞生产者线程，直到队列可用或者响应中断退出。当队列空时，如果消费者线程从队列里take元素，队列会阻塞住消费者线程，直到队列不为空。
- 超时退出：当阻塞队列满时，如果生产者线程往队列里插入元素，队列会阻塞生产者线程一段时间，如果超过了指定的时间，生产者线程就会退出。
二.七种主要的阻塞队列
自从Java 1.5之后，在java.util.concurrent包下提供了若干个阻塞队列，主要有以下几个：
1.ArrayBlockingQueue：基于数组实现的一个有界阻塞队列，该队列内部维持着一个定长的数据缓冲队列（该队列由数组构成），此队列按照先进先出（FIFO）的原则对元素进行排序，在创建ArrayBlockingQueue对象时必须指定容量大小。ArrayBlockingQueue内部还保存着两个整形变量，分别标识着队列的头部和尾部在数组中的位置。
并且还可以指定公平性与非公平性，默认情况下为非公平的。所谓公平访问队列是指阻塞的线程，可以按照阻塞的先后顺序访问队列，即先阻塞线程先访问队列。非公平性是对先等待的线程是非公平的，当队列可用时，阻塞的线程都可以争夺访问队列的资格，有可能先阻塞的线程最后才访问队列。为了保证公平性，通常会降低吞吐量。我们可以使用以下代码创建一个公平的阻塞队列。
ArrayBlockingQueue fairQueue = new ArrayBlockingQueue(1000,true); 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();
}
2.LinkedBlockingQueue：基于链表实现的一个有界阻塞队列，内部维持着一个数据缓冲队列（该队列由链表构成），此队列按照先进先出的原则对元素进行排序。当生产者往队列中放入一个数据时，队列会从生产者手中获取数据，并缓存在队列内部，而生产者立即返回；只有当队列缓冲区达到最大值缓存容量时（可以通过LinkedBlockingQueue的构造函数指定该值），才会阻塞生产者队列，直到消费者从队列中消费掉一份数据，生产者线程将会被唤醒，反之对于消费者这端的处理也基于同样的原理。在创建LinkedBlockingQueue对象时如果不指定容量大小，则默认大小为Integer.MAX_VALUE。这样的话，如果生产者的速度一旦大于消费者的速度，也许还没有等到队列满阻塞产生，系统内存就有可能已经被消耗殆尽了。
LinkedBlockingQueue之所以能够高效的处理并发数据，是因为其对于生产者端和消费者端分别采用了独立的锁来控制数据同步，这也意味着在高并发的情况下生产者和消费者可以并行地操作队列中的数据，以此来提高整个队列的并发性能。
3.PriorityBlockingQueue：支持优先级排序的无界阻塞队列，以上2种队列都是先进先出队列，而PriorityBlockingQueue却不是，它会按照元素的优先级对元素进行排序，默认情况下元素采取自然顺序排列，也可以通过构造函数传入的Compator对象来决定。并且也是按照优先级顺序出队，每次出队的元素都是优先级最高的元素。在实现PriorityBlockingQueue时，内部控制线程同步的锁采用的是公平锁。需要注意的是PriorityBlockingQueue并不会阻塞数据生产者，而只是在没有可消费的数据时阻塞数据的消费者，因此使用的时候要特别注意，生产者生产数据的速度绝对不能快于消费者消费数据的速度，否则时间一长，会最终耗尽所有的可用堆内存空间。注意，此阻塞队列为无界阻塞队列，即容量没有上限（通过源码就可以知道，它没有容器满的信号标志）。
4.DelayQueue：基于PriorityQueue，一种支持延时的获取元素的无界阻塞队列，DelayQueue中的元素只有当其指定的延迟时间到了，才能够从队列中获取到该元素。DelayQueue也是一个无界队列，因此往队列中插入数据的操作（生产者）永远不会被阻塞，而只有获取数据的操作（消费者）才会被阻塞。
transfer()方法：如果当前有消费者正在等待接收元素（消费者使用take()方法或带时间限制的poll()方法），transfer()方法可以把生产者传入的元素立刻传输给消费者；如果没有消费者在等待接收元素，transfer()方法会将元素存放到队列的tail节点，并等到该元素被消费者消费了才返回。
transfer()方法的关键代码如下：
Node pred = tryAppend(s, haveData); return awaitMatch(s, pred, e, (how == TIMED), nanos);
第一行代码是试图把存放当前元素的s节点作为tail节点，第二行代码是让CPU自旋等待消费者消费元素。因为自旋会消耗CPU，所以自旋一定的次数后使用Thread.yield()方法来暂停当前正在执行的线程，并执行其他线程。
tryTransfer()方法：该方法是用来试探生产者传入的元素是否能直接传给消费者，如果没有消费者等待接收元素，则返回false。与transfer()方法的区别：tryTransfer()方法是立即返回（无论消费者是否接收），transfer()方法是必须等到消费者消费了才返回。对于带有时间限制的tryTransfer(E e, long timeout, TimeUnit unit)方法，则是试图把生产者传入的元素直接传给消费者，但是如果没有消费者消费该元素则等待指定的时间之后再返回，如果超时还没消费元素，则返回false，如果在超时时间内消费了元素，则返回true。
public class ArrayBlockingQueue<E> extends AbstractQueue<E> implements BlockingQueue<E>, java.io.Serializable { /** * Serialization ID. This class relies on default serialization * even for the items array, which is default-serialized, even if * it is empty. Otherwise it could not be declared final, which is * necessary here. */ private static final long serialVersionUID = -817911632652898426L; /** The queued items */ final Object[] items; /** items index for next take, poll, peek or remove */ int takeIndex; /** items index for next put, offer, or add */ int putIndex; /** Number of elements in the queue */ int count; /** Main lock guarding all access */ final ReentrantLock lock; /** Condition for waiting takes */ private final Condition notEmpty; /** Condition for waiting puts */ private final Condition notFull; transient Itrs itrs = null;
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(); //释放锁 } } private void enqueue(E x) {//相当于add()方法 final Object[] items = this.items; items[putIndex] = x;//在队尾添加元素 if (++putIndex == items.length)//索引自增，如果已是最后一个位置，重新设置 putIndex = 0 putIndex = 0; count++; notEmpty.signal(); } 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() {//相当于remove() final Object[] items = this.items;//获取数组容器 E x = (E) items[takeIndex];//获取队首元素，因为ArrayBlockingQueue是先进先出队列 items[takeIndex] = null;//将该位置置空 if (++takeIndex == items.length)//索引自增，如果已是最后一个位置，重新设置 putIndex = 0 takeIndex = 0; count--;//将容器中元素个数减一 if (itrs != null) itrs.elementDequeued(); notFull.signal();//唤醒其他被阻塞的线程，由于刚才生产者因容器已满而被阻塞掉，这时候就会被该线程唤醒了，唤醒之后就可继续它的生产工作。 return x; }
