在前面我们提到了阻塞队列，也用过了LinkedBolckingQueue队列了，在这里，我们主要对 ArrayBlockingQueue，PriorityBlockingQueue，DelayQueue，SynchronousQueue，LinkedTransferQueue，LinkedBlockingDeque的使用方法和应用场景做一个补充。
- ArrayBlockingQueue：基于数组实现的阻塞队列，先进先出队列，有界队列。在创建时必须制定容量大小。并可以指定公平性与非公平性，默认情况下是非公平的，即不保证等待时间最长的队列最优先能够访问队列。
- LinkedBlockingQueue：基于链表实现的阻塞队列，先进先出队列，有界队列。在创建时如果不指定容量大小，则默认大小为Integer.MAX_VALUE。
- PriorityBlockingQueue：按照元素的优先级对元素进行排序，按照优先级顺序出队。并且该阻塞队列为无界阻塞队列，即容量没有上限（源码中它没有容器满的信号标志）。
- DelayQueue：基于PriorityQueue的延时阻塞队列，无界队列。DelayQueue中的元素只有当其指定的延迟时间到了，才能够从队列中获取到该元素。因为DelayQueue是一个无界队列，所以往队列中插入数据的操作永远不会被阻塞，而只有获取数据的操作才会被阻塞。
- SynchronousQueue：一个不存储元素的阻塞队列。
- LinkedTransferQueue：一个由链表结构组成的无界阻塞队列。
- LinkedBlockingDeque：一个由链表结构组成的双向阻塞队列。
（1） ArrayBlockingQueue示例：
import java.util.concurrent.ArrayBlockingQueue;
public class ArrayBolckingQueueDemo {
static ArrayBlockingQueue<String> queue = new ArrayBlockingQueue<>(2);
public static void main(String[] args) {
ArrayBolckingQueueDemo demo = new ArrayBolckingQueueDemo();
Product p = demo.new Product();
Eat e = demo.new Eat();
Thread t1 = new Thread(e);
Thread t2 = new Thread(p);
t2.start();
t1.start();
}
class Product implements Runnable {
@Override
public void run() {
while (true) {
try {
queue.put("apple");
System.out.println(Thread.currentThread().getName() + "put queue:" + queue.toString());
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
class Eat implements Runnable {
@Override
public void run() {
while (true) {
try {
queue.take();
System.out.println(Thread.currentThread().getName() + "eat queue:" + queue.toString());
Thread.sleep(1500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}结果：
（2）LinkedBlockingQueue示例这里不介绍，大家可以看我前面的博客“Java多线程_阻塞队列”
（3）PriorityBlockingQueue示例：
import java.util.concurrent.PriorityBlockingQueue; public class PriorityBlockingQueueDemo { public static void main(String[] args) { PriorityBlockingQueue<People> queue = new PriorityBlockingQueue<>(); PriorityBlockingQueueDemo demo = new PriorityBlockingQueueDemo(); queue.put(demo.new People("tom", 19)); queue.put(demo.new People("jack", 18)); queue.put(demo.new People("tony", 21)); while (!queue.isEmpty()) { try { System.out.println(queue.take().toString()); } catch (InterruptedException e) { e.printStackTrace(); } } } class People implements Comparable<People> { private String name; private Integer age; public People(String name, Integer age) { super(); this.name = name; this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public Integer getAge() { return age; } public void setAge(Integer age) { this.age = age; } @Override public int compareTo(People o) { if (this.age > o.age) { return 1; } else { return -1; } } @Override public String toString() { // TODO Auto-generated method stub return "name:" + name + " age:" + age; } } }
结果：
（4）DelayQueue应用场景：
1) 关闭空闲连接。服务器中，有很多客户端的连接，空闲一段时间之后需要关闭。
2) 缓存。缓存中的对象，超过了空闲时间，需要从缓存中移出。
3) 任务超时处理。
import java.util.concurrent.DelayQueue; import java.util.concurrent.Delayed; import java.util.concurrent.TimeUnit; public class DelayQueueDemo { public static void main(String[] args) { DelayQueueDemo demo = new DelayQueueDemo(); DelayQueue<People> queue = new DelayQueue<>(); queue.put(demo.new People("tom", 4000 + System.currentTimeMillis())); queue.put(demo.new People("jack", 1000 + System.currentTimeMillis())); queue.put(demo.new People("tony", 6000 + System.currentTimeMillis())); while (!queue.isEmpty()) { try { System.out.println(queue.take().toString()); } catch (InterruptedException e) { e.printStackTrace(); } } } class People implements Delayed { private String name; private long time;// 截止时间 public People(String name, long time) { super(); this.name = name; this.time = time; } public String getName() { return name; } public void setName(String name) { this.name = name; } public long getTime() { return time; } public void setTime(long time) { this.time = time; } @Override public String toString() { return "name:" + name + " time:" + time; } @Override public int compareTo(Delayed o) { People p = (People) o; if (time - p.time > 0) { return 1; } else { return -1; } } @Override public long getDelay(TimeUnit unit) { return time - System.currentTimeMillis(); } } }
结果：
（5）SynchronousQueue示例：
注意点：每个 put 必须等待一个 take，反之亦然。
import java.util.Random; import java.util.concurrent.SynchronousQueue; public class SynchronousQueueDemo { static SynchronousQueue<Integer> queue = new SynchronousQueue<>(); public static void main(String[] args) { SynchronousQueueDemo demo = new SynchronousQueueDemo(); Productor p = demo.new Productor(); Consumer c = demo.new Consumer(); Thread t1 = new Thread(p); Thread t2 = new Thread(c); t1.start(); t2.start(); } class Productor implements Runnable { @Override public void run() { while (true) { int data = new Random().nextInt(1000); System.out.println("put " + data); try { queue.put(data); Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } } } class Consumer implements Runnable { @Override public void run() { while (true) { try { System.out.println("take " + queue.take()); Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } } } }
结果：
（6）LinkedBlockingDeque和LinkedTransferQueue
这两个队列都是后期才产生的队列。
LinkedTransferQueue是一个由链表结构组成的无界阻塞队列。他与LinkedBolckingQueue最大的不同就是这个队列是无界的，而LinkedBolckingQueue是有界的，用法大致相同，这里不作介绍。
LinkedBlockingDeque最大的不同就是它是一个双向的基于链表的阻塞队列。该阻塞队列同时支持FIFO和FILO两种操作方式，即可以从队列的头和尾同时操作(插入/删除)，用法差别也不大，不作介绍。
