多线程-JUC学习-JUC集合-BlockingQueue
阻塞队列 BlockingQueue
java.util.concurrent 包里的 BlockingQueue 接口表示一个线程放入和提取实例的队列
阻塞队列（BlockingQueue）是一个支持两个附加操作的队列。这两个附加的操作支持阻塞的插入和移除方法
1）支持阻塞的插入方法：意思是当队列满时，队列会阻塞插入元素的线程，直到队列不满。
2）支持阻塞的移除方法：意思是在队列为空时，获取元素的线程会等待队列变为非空
BlockingQueue 用法
BlockingQueue 通常用于一个线程生产对象，而另外一个线程消费这些对象的场景。下图是对这个原理的阐述：
一个线程往里边放，另外一个线程从里边取的一个 BlockingQueue。
- 一个线程将会持续生产新对象并将其插入到队列之中，直到队列达到它所能容纳的临界点。也就是说，它是有限的。如果该阻塞队列到达了其临界点，负责生产的线程将会在往里边插入新对象时发生阻塞。它会一直处于阻塞之中，直到负责消费的线程从队列中拿走一个对象。
- 负责消费的线程将会一直从该阻塞队列中拿出对象。如果消费线程尝试去从一个空的队列中提取对象的话，这个消费线程将会处于阻塞之中，直到一个生产线程把一个对象丢进队列。
BlockingQueue 的方法
BlockingQueue 具有 4 组不同的方法用于插入、移除以及对队列中的元素进行检查。如果请求的操作不能得到立即执行的话，每个方法的表现也不同。这些方法如下：
| 抛异常 | 特定值 | 阻塞 | 超时 | |
|---|---|---|---|---|
| 插入 | add(o) | offer(o) | put(o) | offer(o, timeout, timeunit) |
| 移除 | remove(o) | poll(o) | take(o) | poll(timeout, timeunit) |
| 检查 | element(o) | peek(o) |
四组不同的行为方式解释：
- 抛异常：如果试图的操作无法立即执行，抛一个异常。
- 特定值：如果试图的操作无法立即执行，返回一个特定的值(常常是 true / false)。
- 阻塞：如果试图的操作无法立即执行，该方法调用将会发生阻塞，直到能够执行。
- 超时：如果试图的操作无法立即执行，该方法调用将会发生阻塞，直到能够执行，但等待时间不会超过给定值。返回一个特定值以告知该操作是否成功(典型的是 true / false)
- 无法向一个 BlockingQueue 中插入 null。如果你试图插入 null，BlockingQueue 将会抛出一个 NullPointerException。
- 可以访问到 BlockingQueue 中的所有元素，而不仅仅是开始和结束的元素。比如说，你将一个对象放入队列之中以等待处理，但你的应用想要将其取消掉。那么你可以调用诸如 remove(o) 方法来将队列之中的特定对象进行移除。但是这么干效率并不高(译者注：基于队列的数据结构，获取除开始或结束位置的其他对象的效率不会太高)，因此你尽量不要用这一类的方法，除非你确实不得不那么做。
BlockingQueue 的实现
- ArrayBlockingQueue
- DelayQueue
- LinkedBlockingQueue
- PriorityBlockingQueue
- SynchronousQueue
一、数组阻塞队列ArrayBlockingQueue
同过一个简单的生产消费模型，可以看出效果。当队列里的存放到达最大容量是，生产者会阻塞着，得消费者取走消息。容器里面有新的空间后，继续存放。效果复制以下代码，执行main方法就行
public class Consumer implements Runnable {
private BlockingQueue MQlist = null;
public Consumer(BlockingQueue MQlist) {
this.MQlist = MQlist;
}
@Override
public void run() {
try {
while (true) {
Thread.sleep(500);
String name = Thread.currentThread().getName();
String take = MQlist.take();
System.out.println("消费者"+name+"获取了"+take);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public class Producer implements Runnable {
private BlockingQueue MQlist = null;
public Producer(BlockingQueue MQlist) {
this.MQlist = MQlist;
}
@Override
public void run() {
try {
for (int i = 0; i < 10; i++) {
Thread.sleep(500);
String name = Thread.currentThread().getName();
MQlist.put(name + ":" + i);
System.out.println("生产者"+name+"存放了"+i);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
} public class Demo {
public static void main(String[] args) {
BlockingQueue bq=new ArrayBlockingQueue(5);
//producer是一个线程任务类，执行的方法是往队列里放10条数据
Producer producer=new Producer(bq);
//consumer是线程任务类，执行方法是往队列里拿数据 他两的队列是同一个队列，
Consumer consumer=new Consumer(bq);
new Thread(producer).start();
new Thread(consumer).start();
new Thread(producer).start();
new Thread(consumer).start();
new Thread(producer).start();
}
}
二、链式阻塞队列（LinkedBlockingQueue）
生产者会一直放下去，最后是consumer在消费
public class Demo {
public static void main(String[] args) {
BlockingQueue bq=new LinkedBlockingQueue(5);
//producer是一个线程任务类，执行的方法是往队列里放10条数据
Producer producer=new Producer(bq);
//consumer是线程任务类，执行方法是往队列里拿数据 他两的队列是同一个队列，
Consumer consumer=new Consumer(bq);
new Thread(producer).start();
new Thread(consumer).start();
new Thread(producer).start();
new Thread(consumer).start();
new Thread(producer).start();
}
}
三、优先级队列（PriorityBlockingQueue）
带优先级的无界阻塞队列，每次出队都返回优先级最高的元素，是二叉树最小堆的实现，研究过数组方式存放最小堆节点的都知道，直接遍历队列元素是无序的。该实现类需要自己实现一个继承了 Comparator 接口的类， 在插入资源时会按照自定义的排序规则来对资源数组进行排序。
package com.blockingqueue.PriorityBlockingQueue;
/**
* @Author zongx
* @Date 2020/6/5 17:16
* @Version 1.0
*/
public class Person implements Comparable {
int age;
String name;
@Override
public String toString() {
return "Person{" +
"age=" + age +
", name='" + name + '\'' +
'}';
}
public Person(int age, String name) {
this.age = age;
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public int compareTo(Person o) {
return this.age - o.age;
}
}
package com.blockingqueue.PriorityBlockingQueue;
import java.util.Random;
import java.util.concurrent.BlockingQueue;
/**
* @Author zongx
* @Date 2020/6/5 16:00
* @Version 1.0
*/
public class Producer implements Runnable {
private BlockingQueue MQlist = null;
public Producer(BlockingQueue MQlist) {
this.MQlist = MQlist;
}
@Override
public void run() {
try {
for (int i = 0; i < 10; i++) {
Thread.sleep(500);
String name = Thread.currentThread().getName();
double random = Math.random();
int j = (int) (i*random*10);
Person person = new Person(j, name);
MQlist.put(person);
System.out.println("生产者"+name+"存放了"+i);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
package com.blockingqueue.PriorityBlockingQueue;
import java.util.concurrent.BlockingQueue;
/**
* @Author zongx
* @Date 2020/6/5 16:04
* @Version 1.0
*/
public class Consumer implements Runnable {
private BlockingQueue MQlist = null;
public Consumer(BlockingQueue MQlist) {
this.MQlist = MQlist;
}
@Override
public void run() {
try {
while (true) {
Thread.sleep(2000);
String name = Thread.currentThread().getName();
Person take = MQlist.take();
System.out.println("消费者"+name+"获取了"+take);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
package com.blockingqueue.PriorityBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.PriorityBlockingQueue;
/**
* @Author zongx
* @Date 2020/6/5 16:07
* @Version 1.0
*/
public class Demo {
public static void main(String[] args) {
BlockingQueue bq=new PriorityBlockingQueue(5);
//producer是一个线程任务类，执行的方法是往队列里放10条数据
Producer producer=new Producer(bq);
//consumer是线程任务类，执行方法是往队列里拿数据 他两的队列是同一个队列，
Consumer consumer=new Consumer(bq);
new Thread(producer).start();
new Thread(producer).start();
new Thread(consumer).start();
}
}
四、延迟队列（ DelayQueue）
DelayQueue是一个无界阻塞队列，只有在延迟期满时才能从中提取元素。该队列的头部是延迟期满后保存时间最长的Delayed 元素。为了具有调用行为，存放到DelayDeque的元素必须继承Delayed接口。Delayed接口使对象成为延迟对象，它使存放在DelayQueue类中的对象具有了激活日期。该接口强制执行下列两个方法。
- CompareTo(Delayed o)：Delayed接口继承了Comparable接口，因此有了这个方法。
- getDelay(TimeUnit unit):这个方法返回到激活日期的剩余时间，时间单位由单位参数指定
做任务调度：离到期时间越近，越早，当时间等于0调用
package com.blockingqueue.DelayQueue;
import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;
/**
* @Author zongx
* @Date 2020/6/5 17:46
* @Version 1.0
*/
public class Duty implements Delayed {
private String name;
private long expireTime;
//定义时间工具类
private TimeUnit timeUnit = TimeUnit.SECONDS;
@Override
public long getDelay(TimeUnit unit) {
return expireTime - System.currentTimeMillis();
}
@Override
public int compareTo(Delayed o) {
if (this.getDelay(timeUnit) - o.getDelay(timeUnit) > 0){
return 1;
}else if (this.getDelay(timeUnit) - o.getDelay(timeUnit) < 0){
return -1;
}else {
return 0;
}
}
public Duty(String name, long expireTime) {
this.name = name;
this.expireTime = expireTime;
}
@Override
public String toString() {
return "Duty{" +
"name='" + name + '\'' +
", expireTime=" + (expireTime-1591351020000l) +
'}';
}
}
package com.blockingqueue.DelayQueue;
import com.blockingqueue.PriorityBlockingQueue.Person;
import java.util.concurrent.BlockingQueue;
/**
* @Author zongx
* @Date 2020/6/5 16:00
* @Version 1.0
*/
public class Producer implements Runnable {
private BlockingQueue MQlist = null;
public Producer(BlockingQueue MQlist) {
this.MQlist = MQlist;
}
@Override
public void run() {
try {
for (int i = 0; i < 3; i++) {
Thread.sleep(500);
String name = Thread.currentThread().getName();
double random = Math.random();
long j = (long) (i*random*1000) + System.currentTimeMillis();
Duty person = new Duty( name,j);
MQlist.put(person);
System.out.println("生产者"+name+"存放了"+(int) (i*random*1000));
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
package com.blockingqueue.DelayQueue;
import com.blockingqueue.PriorityBlockingQueue.Person;
import java.util.concurrent.BlockingQueue;
/**
* @Author zongx
* @Date 2020/6/5 16:04
* @Version 1.0
*/
public class Consumer implements Runnable {
private BlockingQueue MQlist = null;
public Consumer(BlockingQueue MQlist) {
this.MQlist = MQlist;
}
@Override
public void run() {
try {
while (true) {
Thread.sleep(2000);
String name = Thread.currentThread().getName();
Duty take = (Duty) MQlist.take();
System.out.println("消费者"+name+"获取了"+take);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
package com.blockingqueue.DelayQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.DelayQueue;
import java.util.concurrent.PriorityBlockingQueue;
/**
* @Author zongx
* @Date 2020/6/5 16:07
* @Version 1.0
*/
public class Demo {
public static void main(String[] args) {
BlockingQueue bq=new DelayQueue();
//producer是一个线程任务类，执行的方法是往队列里放10条数据
Producer producer=new Producer(bq);
//consumer是线程任务类，执行方法是往队列里拿数据 他两的队列是同一个队列，
Consumer consumer=new Consumer(bq);
new Thread(producer).start();
new Thread(producer).start();
new Thread(consumer).start();
}
}
应用场景：
- DelayQueue阻塞队列在我们系统开发中也常常会用到，例如：缓存系统的设计，缓存中的对象，超过了空闲时间，需要从缓存中移出；任务调度系统，能够准确的把握任务的执行时间。
- 多考试上机考试的场景：来自于http://ideasforjava.iteye.com/blog/657384，模拟一个考试的日子，考试时间为120分钟，30分钟后才可交卷，当时间到了，或学生都交完卷了考试结束。
- 具有时间的缓存场景：来自于http://www.cnblogs.com/jobs/archive/2007/04/27/730255.html，向缓存添加内容时，给每一个key设定过期时间，系统自动将超过过期时间的key清除。
五、同步队列（SynchronousQueue）
特点：
- 1、SynchronousQueue没有容量。与其他BlockingQueue不同，SynchronousQueue是一个不存储元素的BlockingQueue.每一个put操作必须要等待一个take操作，否则不能继续添加元素，反之亦然。
- 2、因为没有容量，所以对应 peek, contains, clear, isEmpty … 等方法其实是无效的。例如clear是不执行任何操作的，contains始终返回false,peek始终返回null。
- 3、SynchronousQueue分为公平和非公平，默认情况下采用非公平性访问策略，当然也可以通过构造函数来设置为公平性访问策略（为true即可）。
- 4、若使用 TransferQueue, 则队列中永远会存在一个 dummy node（这点后面详细阐述）。
/**
* 不像ArrayBlockingQueue、LinkedBlockingDeque之类的阻塞队列依赖AQS实现并发操作，
* SynchronousQueue直接使用CAS实现线程的安全访问。它是个没有容量的队列，
*/
public static void main(String[] args) throws Exception {
final BlockingQueue bq=new SynchronousQueue<>();
//第一种情况 这种直接添加，会出异常Queue full
//bq.add("steve");
//第二种情况 如果有线程先取，会阻塞着，这样就能放进去
new Thread(new Runnable() {
@Override
public void run() {
try {
System.out.println( bq.take());
} catch (Exception e) {
e.printStackTrace();
}
}
}).start();
Thread.sleep(1000);
//可以理解为交接给了等待的线程,不是真正的存放进去了
bq.put("stevetao");
} 
