Queue接口继承了Collection接口，其内部定义了六个方法，分为三大类，分别是新增元素、删除元素、检索元素。每一个大类都提供了两个方法，这两个方法的作用可以用下面的表格来描述：
（1）.add()和offer()：这两个方法是向队列添加元素，不同之处在于如果队列已经添加满了还继续添加add()方法就会抛出异常，而offer()会返回false值（如果队列没有满，则offer（）添加成功后会返回true）。
（2）.remove()和poll()：这两个方法都是返回队列顶元素并且从队列中删除。不同的是，如果在删除时队列里没有元素了那么remove则会抛异常，而poll则会返回null。
（3）.element()和peek()：这两个方法都是取队列顶部元素但是不删除，和remove（）、poll（）有所区别。当队列没有元素时element（）会抛异常，而peek（）会返回null。
一、双向队列Deque
双向队列可以双向操作，比如添加元素可以从两头添加、删除和获取都可以从收尾删除获取，这些操作都对应于相应的last和first方法。Deque也是一个双向队列接口，其下的实现由ArrayDeque（它的大小没有限制，也可以手动限制）。
下面我们看双向队列的实现原理。我们以ArrayDeque类分析。
其实如果在创建ArrayDeque对象时不指定其初始大小它默认的就是16，如果在使用的时候发现不够就会拓展。双向队列的数据存储实际上时用数组来存储的，在ArrayDeque中有一个全局的E[] elements，数组，之后所有的增删改查都与此数据息息相关，此外还有两个比较重要的变量就是head和tail变量，分别表示队列首部和尾部。当我们从队列的头部取值时head值会自动+1，且会将elements[head]元素置为null（如果是remove方法或poll方法）,如果是从队列的尾部取值，则tail的值会自动-1.其实现原理如下：
public E pollFirst() {
int h = head;
E result = elements[h]; // Element is null if deque empty
if (result == null)
return null;
elements[h] = null; // Must null out slot
head = (h + 1) & (elements.length - 1);
return result;
}
public E pollLast() {
int t = (tail - 1) & (elements.length - 1);
E result = elements[t];
if (result == null)
return null;
elements[t] = null;
tail = t;
return result;
}
二、阻塞队列BlockingQueue
先来总结下BlockingQueue的特性：
1、阻塞队列在我们处理生产者-消费者模式的时候是很有用的，尤其是如果有大量网络请求的应用场景。当队列里的元素为空时，他就等处于等待状态，等待队列里存储进新的任务或元素。
2、BlockingQueue的四种类型的方法，每一种类型都有不一样的操作，有时候可以根据不同的场景去使用。这四种不同的类型分别是：抛出异常、返回一个特定的值（null、false、0等）、无限期的阻塞当前线程直到操作成功、在放弃任务之前等待的时间。
3、BlockingQueue不接受null元素。
4、BlockingQueue必须有一个容量限制。
5、BlockingQueue是线程安全的，其所有的方法都有内部的Lock保证安全。
6、BlockingQueue没有任何类似“close”、“shutdown”等操作去指示不能添加更多的元素。
如下便是四种不同类型的方法，和普通的Queue就多了个阻塞机制：
| Throws exception | Special value | Blocks | Times out | |
| Insert | add(e) |
offer(e) |
put(e) |
offer(e, time, unit) |
| Remove | remove() |
poll() |
take() |
poll(time, unit) |
| Examine | element() |
peek() |
not applicable | not applicable |
方法的用于上述图标已经很明了，下面我们看一个典型的生产者和消费者的例子：
（1）生产者
/**
* 生产者
*
* @author Administrator
*
*/
public static class Producer implements Runnable {
private final BlockingQueue queue;
Producer(BlockingQueue q) {
queue = q;
}
public void run() {
try {
while (true) {
// 生产对象/任务,
queue.put(produce());
}
} catch (InterruptedException ex) {
}
}
Object produce() {
cout++;
return "第" + cout + "个任务";
}
}
（2）消费者
/**
* 消费者
*
* @author Administrator
*
*/
public static class Consumer implements Runnable {
private final BlockingQueue queue;
Consumer(BlockingQueue q) {
queue = q;
}
public void run() {
try {
while (true) {
// 从队列取出元素/任务,如果没有任务就会一直处于等待状态
consume(queue.take());
}
} catch (InterruptedException ex) {
}
}
// 实际的消费行为
void consume(Object x) {
System.out.println(x);
}
}
最后开启任务：
public static int cout = 1;
public static void main(String[] args) {
BlockingQueue queue = new ArrayBlockingQueue(10);
Producer pro = new Producer(queue);
Consumer con = new Consumer(queue);
// 开始生产
new Thread(pro).start();
// 开始消费
new Thread(con).start();
}
实际上，在很多场景都有这种生产者-消费者模式，比如在Volley中其就使用到了BlockingQueue来接收请求，然后获取任务从而发起请求。（注：生产者-消费者模式很经典，在操作系统中PV锁控制的中断也可以实现类似生产者-消费者模式）。
常用的阻塞队列
其实从上面的代码可能已经猜出来了，BlockingQueue只不过是一个接口，其下有众多的不同实现类，下面就简单介绍下其实现类以及使用的场景：
ArrayBlockingQueue
一个由数组支持的有限阻塞队列（其大小在创建的时候就被确定，并且不能在修改）。此队列里存储的元素顺序是FIFO（first-in-first-out），是一个很标准的普通队列，也是我们最常使用到的阻塞队列。其头部的元素是在队列带的时间最长，尾部元素在队列中呆的时间最短，新来的元素是插在尾部的，而当队列获取元素时是从头部获取的。如果试图将一个元素put到一个full状态的队列，这个操作就会被阻塞，直到队列有空位置。如果从一个empty队列获取新的元素同样也会被阻塞，知道有元素可获取。
此类为等待的消费者/生产者提供了一个可选的公平的处理策略。此类默认的不保证阻塞的顺序。可以看到ArrayBlockingQueue有三个构造器，第一个就是只提供一个容量，第二个构造器的第一个参数就是容量，第二个参数就是是否公平加入/移除队列，如果设置为true就会按照FIFO的顺序来入队列和出队列，如果为false就不保证顺序了。一个参数的构造器默认的是false。
DelayQueue
此队列是一个无界限的队列，只有当他的元素在队列中超过规定时间了他才可以被取出来，其头部是超期时间最长的元素，尾部就是超期最短（或还未过期）的元素。如果还没有过期的元素，那么就不存在头部了，将直接返当回null，他的队列调用了元素的getDelay（）方法返回的值小于或等于0就表示过期了。
这个队列不是所有的元素都可以放进去的，必须是实现了Delayed接口的类对象才可以放进去，否则就会报类型转换异常，那么什么是Delayed接口呢？它很简单，直接去看其API吧！我们暂时只需要知道如何使用就行！下面给出一个场景用DelayQueue实现：
作为上班族是不能迟到早退的，不然扣钱扣得那叫一个惨不忍睹....亲身体验，我有一次就年会那天直接去年会现场了，没有来打卡就扣了好几百啊有木有，就半天时间啊有木有，说多了都是泪...言归正传。有一天Boss让小A去加个班，并让小A不管工作有没有做完必须在晚上24点才能下班（我们先假设这个工作加班到死也一下子做不完），在小班后小A还得打卡验证。那么程序如何模拟呢？下面上代码：
（1）老板类
/**
* 老板
*
* @author Administrator
*
*/
public static class Boss implements Runnable {
private final BlockingQueue queue;
Boss(BlockingQueue q) {
queue = q;
}
public void run() {
try {
// 告诉小A去加班啊，别偷懒，下班记得在24点打卡啊
queue.put(produce());
// }
} catch (InterruptedException ex) {
}
}
private Object produce() {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
try {
// 这里指定啥时候下班:老板让他在24点下班
Date date = sdf.parse("2089-06-18 24:00:00");
// 构造器传递一个long类型的数值
return new DelayObject(date.getTime());
} catch (ParseException e) {
e.printStackTrace();
}
return null;
}
}
（2）小A
/**
* 存放到DelayQueue的元素必须实现Delay接口
*
* @author Administrator
*
*/
private static class 小A implements Delayed {
static int count = 1;
static long delay = 1;
public 小A(long delay) {
this.delay = delay;
count++;
}
public int compareTo(Delayed o) {
return 0;
}
/**
* 队列会不停调用此方法(比如take（）方法里有个死循环，会不断调用getDelay())判断该元素是否可以取出来，
* 因此此参数不应该是一个固定的，应该和系统时间关联，即随着时间的推移 可以使得这个元素可以使用
* 当这个返回值小于等于0的时候就可以从队列中取出这个元素了
*/
public long getDelay(TimeUnit unit) {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
// 每次调用getDelay（）时都重新计时
Date date = new Date();
String sd = sdf.format(date);
try {
Date d2 = sdf.parse(sd); // 前的时间
long diff = delay - d2.getTime(); // 两时间差，精确到毫秒
// 此diff会1秒秒的减小，当其为0的时候就不再调用了，直接就可以出队列了。
return diff;
} catch (ParseException e) {
e.printStackTrace();
}
return 0;
}
/**
* 下班了
*/
public void free() {
System.out.println("哈哈哈哈哈哈---我下班了");
}
}
（3）考勤系统
/**
* 公司的考勤系统
*
* @author Administrator
*
*/
public static class SystemWorker implements Runnable {
private final BlockingQueue queue;
SystemWorker(BlockingQueue q) {
queue = q;
}
public void run() {
try {
while (true) {
// 只要还没到下班时间，他就一直处于阻塞状态，等待
offWork(queue.take());
}
} catch (InterruptedException ex) {
}
}
// 下班打卡:其参数就是具体的某个员工下班
void offWork(Object x) {
小A delay = (小A) x;
// 如果能下班就说
delay.free();
}
}
（4）正式运作
BlockingQueue queue = new DelayQueue();
Boss pro = new Boss(queue);
SystemWorker con = new SystemWorker(queue);
// 老板发话
new Thread(pro).start();
// 系统开始工作
new Thread(con).start();
LinkedBlockingQueue
是一个基于连接节点的任意大小容量的队列，这个队列的顺序是FIFO，其头部是存入队列最早的元素，尾部是存入队列最晚的元素，每次都是讲元素插入尾部，从头部取出元素。LinkedBlockingQueue:比ArrayBlockingQueue有更大的吞吐量，但是在并发的情况下其性能是不可预测的。
好吧！暂时就介绍以上三种常见常用的队列，另外还有LinkedTransferQueue、PriorityBlockingQueue、SynchronousQueue三种大家可以自行查看API使用。