队列(Queue)，是一种数据结构。除了优先级队列和LIFO队列外，队列都是以FIFO（先进先出）的方式对各个元素进行排序的。
BlockingQueue
而阻塞队列BlockingQueue除了继承队列的所有方法外，还分别新增了支持阻塞的插入(put)和移除(take)方法。
下面我们分别看下JDK提供的七个阻塞队列
ArrayBlockingQueue
ArrayBlockingQueue是一个用数组实现的有界阻塞队列。此队列按照先进先出（FIFO）的原则对元素进行排序。
看一下它的构造方法
/**
* Creates an {@code ArrayBlockingQueue} with the given (fixed)
* capacity and the specified access policy.
*
* @param capacity the capacity of this queue
* @param fair if {@code true} then queue accesses for threads blocked
* on insertion or removal, are processed in FIFO order;
* if {@code false} the access order is unspecified.
* @throws IllegalArgumentException if {@code capacity < 1}
*/
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();
}
默认的构造方法是不保证线程公平的访问队列，所谓公平访问队列是指阻塞的线程，可以按照阻塞的先后顺序访问队列，即先阻塞线程先访问队列。
非公平性是对先等待的线程是非公平的，当队列可用时，阻塞的线程都可以争夺访问队列的资格，有可能先阻塞的线程最后才访问队列。为了保证公平性，通常会降低吞吐量。
第15行 lock = new ReentrantLock(fair); 可以看出阻塞队列的公平性也是通过ReentrantLock的公平锁实现的，
第16行和第17行，我们又看到熟悉的 lock.newCondition()，在之前的一篇博客《java多线程6：ReentrantLock》中，说到使用condition可以实现等待/通知模型，
也不难理解，如果想要实现支持阻塞的插入(put)和移除(take)方法，就可以通过condition实现线程间的通信。
LinkedBlockingQueue
LinkedBlockingQueue是一个用链表实现的有界阻塞队列。此队列的默认和最大长度为Integer.MAX_VALUE。此队列按照先进先出的原则对元素进行排序。
offer(E e)： 如果队列满了，立即返回false，如果队列没满，立即返回true
put(E e)：如果队列满了，一直阻塞，直到队列不满了或者线程被中断
offer(E e, long timeout, TimeUnit unit)：在队尾插入一个元素,如果队列已满，则进入等待，直到出现以下三种情况：被唤醒、等待时间超时、当前线程被中断
poll()：如果没有元素，直接返回null；如果有元素，出队
take()：如果队列有值，返回取出的值，如果队列空了，一直阻塞，直到队列不为空或者线程被中断
poll(long timeout, TimeUnit unit)：如果队列不空，出队；如果队列已空且已经超时，返回null；
如果队列已空且时间未超时，则进入等待，直到出现以下三种情况：被唤醒、等待时间超时、当前线程被中断
总结：LinkedBlockingQueue是允许两个线程同时在两端进行入队或出队的操作的，但一端同时只能有一个线程进行操作，这是通过两把锁来区分的；
为了维持底部数据的统一，引入了AtomicInteger的一个count变量，表示队列中元素的个数。
count只能在两个地方变化，一个是入队的方法（可以+1），另一个是出队的方法（可以-1），而AtomicInteger是原子安全的，所以也就确保了底层队列的数据同步。
PriorityBlockingQueue
PriorityBlockingQueue是一个支持优先级的*阻塞队列。默认情况下元素采取自然顺序升序排列。
也可以自定义类实现compareTo()方法来指定元素排序规则，或者初始化PriorityBlockingQueue时，指定构造参数Comparator来对元素进行排序。
需要注意的是不能保证同优先级元素的顺序。
DelayQueue
DelayQueue是一个支持延时获取元素的*阻塞队列。队列使用PriorityQueue来实现。
队列中的元素必须实现Delayed接口，在创建元素时可以指定多久才能从队列中获取当前元素。只有在延迟期满时才能从队列中提取元素。
使用场景：
订单系统，对于30分钟内未支付的订单自动取消
缓存系统，可以用DelayQueue保存缓存元素的有效期，使用一个线程循环查询DelayQueue，一旦能从DelayQueue中获取元素时，表示缓存有效期到了
定时任务，使用DelayQueue保存当天将会执行的任务和执行时间，一旦从DelayQueue中获取到任务就开始执行，比如TimerQueue就是使用DelayQueue实现的
SynchronousQueue
SynchronousQueue是一个不存储元素的阻塞队列。每一个put操作必须等待一个take操作，否则不能继续添加元素。
/**
* 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>();
}
1、公平模式：TransferQueue
采用公平锁，并配合一个FIFO队列（Queue）来管理多余的生产者和消费者
2、非公平模式：TransferStack
采用非公平锁，并配合一个LIFO栈（Stack）来管理多余的生产者和消费者，这也是SynchronousQueue默认的模式
LinkedTransferQueue
LinkedTransferQueue是一个由链表结构组成的*阻塞TransferQueue队列。相对于其他阻塞队列，LinkedTransferQueue多了tryTransfer和transfer方法。
（1）transfer方法如果当前有消费者正在等待接收元素（消费者使用take()方法或带时间限制的poll()方法时），transfer方法可以把生产者传入的元素立刻transfer（传输）给消费者。
如果没有消费者在等待接收元素，transfer方法会将元素存放在队列的tail节点，并等到该元素被消费者消费了才返回。transfer方法的关键代码如下。
（2）tryTransfer方法tryTransfer方法是用来试探生产者传入的元素是否能直接传给消费者。如果没有消费者等待接收元素，则返回false。
和transfer方法的区别是tryTransfer方法无论消费者是否接收，方法立即返回，而transfer方法是必须等到消费者消费了才返回。
LinkedBlockingDeque
LinkedBlockingDeque是一个由链表结构组成的双向阻塞队列。所谓双向队列指的是可以从队列的两端插入和移出元素。
双向队列因为多了一个操作队列的入口，在多线程同时入队时，也就减少了一半的竞争。相比其他的阻塞队列，
LinkedBlockingDeque多了addFirst、addLast、offerFirst、offerLast、peekFirst和peekLast等方法，
以First单词结尾的方法，表示插入、获取（peek）或移除双端队列的第一个元素。
以Last单词结尾的方法，表示插入、获取或移除双端队列的最后一个元素。
另外，插入方法add等同于addLast，移除方法remove等效于removeFirst。
但是take方法却等同于takeFirst，不知道是不是JDK的bug，使用时还是用带有First和Last后缀的方法更清楚。
在初始化LinkedBlockingDeque时可以设置容量防止其过度膨胀。另外，双向阻塞队列可以运用在“工作窃取”模式中。
Fork/Join框架
RecursiveAction：用于没有返回结果的任务。
RecursiveTask：用于有返回结果的任务。
我们看一下如何用Fork/Join框架实现计算 1+2+3+...+100
public class CountTask extends RecursiveTask<Integer> {
// 阈值，设置每个子任务将执行多少计算任务
private static final int THRESHOLD = 2;
private int start;
private int end;
public CountTask(int start, int end) {
this.start = start;
this.end = end;
}
/**
* The main computation performed by this task.
*
* @return the result of the computation
*/
@Override
protected Integer compute() {
int sum = 0;
if (end - start > THRESHOLD) {
int mid = (start + end) / THRESHOLD;
CountTask leftTask = new CountTask(start, mid);
CountTask rightTask = new CountTask(mid + 1, end);
// 执行子任务
leftTask.fork();
rightTask.fork();
// 获取子任务执行结果
Integer leftSum = leftTask.join();
Integer rightSum = rightTask.join();
sum = leftSum + rightSum;
} else {
for (int i = start; i <= end; i++) {
sum += i;
}
}
return sum;
}
public static void main(String[] args) {
ForkJoinPool forkJoinPool = new ForkJoinPool();
CountTask countTask = new CountTask(1, 100);
ForkJoinTask<Integer> submit = forkJoinPool.submit(countTask);
try {
System.out.println(submit.get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
ForkJoinTask与一般任务的主要区别在于它需要实现compute方法，在这个方法里，首先需要判断任务是否足够小，如果足够小就直接执行任务。
如果不足够小，就必须分割成两个子任务，每个子任务在调用fork方法时，又会进入compute方法，看看当前子任务是否需要继续分割成子任务，
如果不需要继续分割，则执行当前子任务并返回结果。使用join方法会等待子任务执行完并得到其结果。
参考文献
1：《Java并发编程的艺术》