阻塞队列 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<String> MQlist = null;
public Consumer(BlockingQueue<String> 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<String> MQlist = null;
public Producer(BlockingQueue<String> 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<Person> {
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<Person> MQlist = null;
public Producer(BlockingQueue<Person> 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<Person> MQlist = null;
public Consumer(BlockingQueue<Person> 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<String> 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");
}