1、下面先简单介绍BlockingQueue接口的五个实现：
ArrayBlockingQueue：基于数组的阻塞队列实现，在ArrayBlockingQueue内部，维护了一个定长的数组，以便缓存队列中的数据对象，其内部没实现读写分离，也就意味着生产和消费者不能完全并行。长度是需要定义的，可以指定先进先出或者先进后出，因为长度是需要定义的，所以也叫有界队列，在很多场合非常适合使用。
LinkedBlockingQueue：基于链表的阻塞队列，同ArrayBlockingQueue类似，其内部也维持着一个数据缓冲队列（该队列由一个链表构成），LinkedBlockingQueue之所以能够高效地处理并发数据，是因为其内部实现采用分离锁（读写分离两个锁），从而实现生产者和消费者操作完全并行运行。需要注意一下，它是一个无界队列。
SynchronousQueue：一种没有缓冲的队列，生产者产生的数据直接会被消费者获取并且立刻消费。
PriorityBlockingQueue：基于优先级别的阻塞队列（优先级的判断通过构造函数传入的Compator对象来决定，也就是说传入队列的对象必须实现Comparable接口），在实现PriorityBlockingQueue时，内部控制线程同步的锁采用的是公平锁，需要注意的是它也是一个无界的队列。
DelayQueue：带有延迟时间的Queue，其中的元素只有当其指定的延迟时间到了，才能够从队列中获取到该元素。DelayQueue中的元素必须先实现Delayed接口，DelayQueue是一个没有大小限制的队列，应用场景很多，比如对缓存超时的数据进行移除、任务超时处理、空闲连接的关闭等等。
2、下面简单用一下ArrayBlockingQueue：
因为是有界队列，所以初始化的时候记得定义长度。下面只是简单说一下添加方法，其他的看一下API即可。添加方法有三个，其中add和put方法效果是一样的，而offer方法可以设置添加的延迟时间并且返回true/false表示添加成功还是失败。
ArrayBlockingQueue<String> arrayQueue = new ArrayBlockingQueue<String>(5); //初始化一定要有长度
arrayQueue.add("a");
arrayQueue.put("b"); //add和put方法其实是一样效果的
arrayQueue.add("c");
arrayQueue.add("d");
arrayQueue.add("e");
boolean flag = arrayQueue.offer("f", 2, TimeUnit.SECONDS); //TimeUnit里面有时分秒等等，意思是多少时间后添加
System.out.println(flag); //会返回false，因为长度为5，f是添加的第六个，所以会添加失败控制台打印结果：
false上面的测试我们可以看到，offer方法就算超长度添加控制台也不会报错的，我们尝试一下add和put的超长添加的结果。
ArrayBlockingQueue<String> arrayQueue = new ArrayBlockingQueue<String>(5); //初始化一定要有长度
arrayQueue.add("a");
arrayQueue.put("b"); //add和put方法其实是一样效果的
arrayQueue.add("c");
arrayQueue.add("d");
arrayQueue.add("e");
//arrayQueue.offer("f"); //用offer超长添加不会报错
//arrayQueue.put("f"); //不会报错，但是线程一直执行不停止
arrayQueue.add("f");下面看一下add方法超长添加的报错：
Exception in thread "main" java.lang.IllegalStateException: Queue full
at java.util.AbstractQueue.add(Unknown Source)
at java.util.concurrent.ArrayBlockingQueue.add(Unknown Source)
at com.demo.testQueue.TestQueue.main(TestQueue.java:22)3、下面介绍的是LinkedBlockingQueue：
上面说到LinkedBlockingQueue是无界队列，它的初始化可以不定义长度，当然，也是可以定义长度的，当初始化定义长度时，超长添加也是像ArrayBlockingQueue一样，add方法会报错，put方法会不停止线程，offer方法会返回false。
下面主要测试添加方法和drainTo方法。添加方法和上面的ArrayBlockingQueue是一样的，而drainTo方法是将队列的一定长度的数据liush到集合中。
//LinkedBlockingQueue<String> linkQueue = new LinkedBlockingQueue<String>(2); //初始化可带长度也可不带
LinkedBlockingQueue<String> linkQueue = new LinkedBlockingQueue<String>();
linkQueue.add("a");
linkQueue.put("b");
linkQueue.add("c");
linkQueue.offer("f");
boolean flag = linkQueue.offer("f", 2, TimeUnit.SECONDS);
List<String> list = new ArrayList<String>();
linkQueue.drainTo(list, 3); //将队列的第一到第三个数据流失到list中，流失后的数据将不在队列里
System.out.println("被drainTo的列表的长度"+list.size());
System.out.println("被drainTo的列表的数据：");
for(String str : list){
System.out.println(str);
}
System.out.println("drainTo方法后队列的数据：");
Iterator<String> ite = linkQueue.iterator();
while(ite.hasNext()){
System.out.println(ite.next());
}控制台结果：
被drainTo后的列表的长度3
被drainTo后的列表的数据：
a
b
c
drainTo方法后队列的数据：
f
f4、接下来接续介绍的是SynchronousQueue。
因为是没有缓冲的队列，生产后即刻消费，所以只是单纯的添加元素是会报错的。
SynchronousQueue<String> queue = new SynchronousQueue<String>()；
queue.add("a");控制台报错：
Exception in thread "main" java.lang.IllegalStateException: Queue full
at java.util.AbstractQueue.add(Unknown Source)
at com.demo.testQueue.TestQueue.main(TestQueue.java:49)但是我们可以这么测试，线程1是获取队列的数据的，线程2是生产数据放进队列中的。
SynchronousQueue<String> queue = new SynchronousQueue<String>();//初始化不能带长度
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
try {
String str = queue.take(); //线程1在获取，这是阻塞的，当线程2一添加，线程1就获取，因为SynchronousQueue是没有容量的
System.out.println(str);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
t1.start();
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
queue.add("abcd"); //线程2往队列里添加元素
}
});
t2.start();控制台结果：
获取的数据：abcd要注意一下的就是，线程1必定要在线程2前启动，不然会报下面的错。
Exception in thread "Thread-1" java.lang.IllegalStateException: Queue full
at java.util.AbstractQueue.add(Unknown Source)
at com.demo.testQueue.TestQueue$2.run(TestQueue.java:67)
at java.lang.Thread.run(Unknown Source)因为上面的三种BlockingQueue接口的实现是比较常用的，下面将会举例说一下使用场景：
5、再将一下基于优先级的阻塞队列PriorityBlockingQueue
因为传入队列的对象必须实现Comparable接口来实现优先级判断，所以我们看一下代码，我将会创建一个叫Task的类来实现comparable接口，有简单的id和name属性，会利用id来进行优先级的判断，id大的将会排列在后面。
public class Task implements Comparable<Task>{ //放进PriorityBlockingQueue队列的对象必须实现Comparable接口
private int id;
private String name;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public int compareTo(Task task) { //重写的compareTo方法就是进行优先级的排序的
return (this.id>task.id?1:this.id<task.id?-1:0); //这里是将id大的排在队列的后面。id小的先被取出来
}
@Override
public String toString() {
return "Task [id=" + id + ", name=" + name + "]";
}
}再看一下测试的代码：
PriorityBlockingQueue<Task> queue = new PriorityBlockingQueue<Task>(); //因为是无界队列，初始化可以不定义长度
Task t1 = new Task();
t1.setId(1);
t1.setName("任务 1");
Task t2 = new Task();
t2.setId(4);
t2.setName("任务 2");
Task t3 = new Task();
t3.setId(3);
t3.setName("任务 3");
Task t4 = new Task();
t4.setId(6);
t4.setName("任务4");
queue.add(t1);
queue.add(t2);
queue.add(t4);
queue.add(t3);
System.out.println("添加元素后的队列："+queue);
queue.take(); //取出元素
System.out.println("取出一个元素后的队列："+queue);控制台的打印：
添加元素后的队列：[Task [id=1, name=任务 1], Task [id=3, name=任务 3], Task [id=6, name=任务4], Task [id=4, name=任务 2]]
取出一个元素后的队列：[Task [id=3, name=任务 3], Task [id=4, name=任务 2], Task [id=6, name=任务4]]我们可以看到：添加进去的元素都是没有进行优先级排序的，只要等取出一个元素后才会进行排序，因为是先排序了才能进行提取操作，这算是一个优化的设计吧，不然每次添加都进行优先级排序的话会影响性能。
6、终于到最后一个DelayQueue了。
上面也说到这是一个带延迟时间的Queue，其中的元素只有到了延迟时间才能被取出来。
元素Task的代码：
public class Task2 implements Delayed{
private String name; //姓名
private Integer id;
private long endTime; //截止时间
private TimeUnit timeUnit = TimeUnit.SECONDS;
//相互比较排序用
@Override
public int compareTo(Delayed delayed) {
Task2 t2 = (Task2)delayed;
return this.getDelay(timeUnit)>t2.getDelay(timeUnit)?1:this.getDelay(timeUnit)<t2.getDelay(timeUnit)?-1:0;
}
//判断是否到了截止时间
@Override
public long getDelay(TimeUnit unit) {
return endTime - System.currentTimeMillis(); //延迟时间的毫秒数减去当前时间毫秒数判断是否到了延迟时间
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public long getEndTime() {
return endTime;
}
public void setEndTime(long endTime) {
this.endTime = endTime;
}
@Override
public String toString() {
return "Task2 [name=" + name + ", id=" + id + ", endTime=" + endTime + "]";
}
}测试的代码：
DelayQueue<Task2> queue = new DelayQueue<Task2>();
Task2 t1 = new Task2();
t1.setId(1);
t1.setName("张三");
t1.setEndTime(1*1000+System.currentTimeMillis()); //记得设置的延迟时间是要延迟的毫秒数加上当前时间毫秒数
Task2 t2 = new Task2();
t2.setId(2);
t2.setName("李四");
t2.setEndTime(10*1000+System.currentTimeMillis());
Task2 t3 = new Task2();
t3.setId(3);
t3.setName("王五");
t3.setEndTime(5*1000+System.currentTimeMillis());
queue.add(t1);
queue.add(t2);
queue.add(t3);
Thread thread1 = new Thread(new Runnable() {
@Override
public void run() {
while(true){ //死循环，将队列的任务全部取出来
Task2 t2;
try {
t2 = queue.take();
System.out.println(t2);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
});
thread1.start();
}控制台结果：可以看到确实是延迟时间短的先被取出来了
Task2 [name=张三, id=1, endTime=1529478869353]
Task2 [name=王五, id=3, endTime=1529478873353]
Task2 [name=李四, id=2, endTime=1529478878353]
295
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
