Queue: 基本上,一个队列就是一个先入先出(FIFO)的数据结构
Queue接口与List、Set同一级别,都是继承了Collection接口。LinkedList实现了Deque接 口
下表显示了jdk1.5中的阻塞队列的操作:
add 增加一个元索 如果队列已满,则抛出一个IIIegaISlabEepeplian异常
remove 移除并返回队列头部的元素 如果队列为空,则抛出一个NoSuchElementException异常
element 返回队列头部的元素 如果队列为空,则抛出一个NoSuchElementException异常
offer 添加一个元素并返回true 如果队列已满,则返回false
poll 移除并返问队列头部的元素 如果队列为空,则返回null
peek 返回队列头部的元素 如果队列为空,则返回null
put 添加一个元素 如果队列满,则阻塞
take 移除并返回队列头部的元素 如果队列为空,则阻塞
remove、element、offer 、poll、peek 其实是属于Queue接口。
阻塞队列的操作可以根据它们的响应方式分为以下三类:aad、removee和element操作在你试图为一个已满的队列增加元素或从空队列取得元素时 抛出异常。当然,在多线程程序中,队列在任何时间都可能变成满的或空的,所以你可能想使用offer、poll、peek方法。这些方法在无法完成任务时 只是给出一个出错示而不会抛出异常
注意:poll和peek方法出错进返回null。因此,向队列中插入null值是不合法的
最后,我们有阻塞操作put和take。put方法在队列满时阻塞,take方法在队列空时阻塞
LinkedBlockingQueue(常用阻塞队列)
LinkedBlockingQueue的容量是没有上限的(说的不准确,在不指定时容量为Integer.MAX_VALUE,不要然的话在put时怎么会受阻呢),但是也可以选择指定其最大容量,它是基于链表的队列,此队列按 FIFO(先进先出)排序元素
LinkedBlockingQueue是一个线程安全的阻塞队列,它实现了BlockingQueue
接口,BlockingQueue接口继承自java.util.Queue
接口,并在这个接口的基础上增加了take和put方法,这两个方法正是队列操作的阻塞版本。
由于LinkedBlockingQueue实现是线程安全的,实现了先进先出等特性,是作为生产者消费者的首选;LinkedBlockingQueue
可以指定容量,也可以不指定,不指定的话,默认最大是Integer.MAX_VALUE;其中主要用到put
和take
方法,put
方法在队列满的时候会阻塞直到有队列成员被消费,take
方法在队列空的时候会阻塞,直到有队列成员被放进来
示例代码:
package com.lky.test;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.junit.Test;
/**
* @Title: testBlockQueue.java
* @Package com.lky.test
* @Description:多线程模拟实现生产者消费者模型(阻塞队列)
* @author lky
* @date 2015年10月24日 下午5:08:01
* @version V1.0
*/
public class testBlockQueue {
private Log log = LogFactory.getLog(testBlockQueue.class);
/**
* @Title: testBlockQueue.java
* @Package com.lky.test
* @Description: 定义阻塞队列
* @author lky
* @date 2015年10月24日 下午5:07:28
* @version V1.0
*/
public class Basket {
// 队列的最大容量为3
BlockingQueue<String> basket = new LinkedBlockingQueue<String>(3);
// 如果队列不满,则放入,否则阻塞等待
public void produce(String apple) throws InterruptedException {
basket.put(apple);
}
// 如果队列不为空,则取出,否则阻塞等待
public String consumer() throws InterruptedException {
return basket.take();
}
}
/**
* @Title: testBlockQueue.java
* @Package com.lky.test
* @Description: 定义生产者
* @author lky
* @date 2015年10月24日 下午5:18:17
* @version V1.0
*/
public class Produce implements Runnable {
private Basket basket;
private String fruit;
public Produce(String fruit, Basket basket) {
this.basket = basket;
this.fruit = fruit;
}
@Override
public void run() {
try {
while (true) {
log.info("[" + Thread.currentThread().getName() + "]" + "开始生产apple----->" + this.fruit);
basket.produce(fruit);
log.info("apple生产完毕!!!!");
Thread.sleep(1000);
}
} catch (Exception e) {
log.error("生产苹果异常!!!!!");
}
}
}
/**
* @Title: testBlockQueue.java
* @Package com.lky.test
* @Description: 定义消费者
* @author lky
* @date 2015年10月24日 下午5:24:31
* @version V1.0
*/
public class Consumer implements Runnable {
private Basket basket;
public Consumer(Basket basket) {
this.basket = basket;
}
@Override
public void run() {
try {
while (true) {
String fruit = basket.consumer();
log.info("[" + Thread.currentThread().getName() + "]" + "取到一个水果: " + fruit);
Thread.sleep(1000);
}
} catch (Exception e) {
log.error("消费者取苹果异常!!!!");
}
}
}
@Test
public void test() {
System.out.println(Runtime.getRuntime().availableProcessors());//获取当前系统的cpu数目
Basket basket = new Basket();
Produce produce1 = new Produce("apple", basket);
Produce produce2 = new Produce("banna", basket);
Consumer consumer = new Consumer(basket);
// 新建一个线程池
ExecutorService service = Executors.newCachedThreadPool();
service.submit(produce1);
service.submit(produce2);
service.submit(consumer);
try {
Thread.sleep(20000);
} catch (Exception e) {
log.error("程序异常错误!!!!");
}
service.shutdown();
}
}
ArrayBlockingQueue
ArrayBlockingQueue在构造时需要指定容量, 并可以选择是否需要公平性,如果公平参数被设置true,等待时间最长的线程会优先得到处理(其实就是通过将ReentrantLock设置为true来 达到这种公平性的:即等待时间最长的线程会先操作)。通常,公平性会使你在性能上付出代价,只有在的确非常需要的时候再使用它。它是基于数组的阻塞循环队列
,此队列按 FIFO(先进先出)原则对元素进行排序。
PriorityBlockingQueue
PriorityBlockingQueue是一个带优先级的 队列,而不是先进先出队列。元素按优先级顺序被移除,该队列也没有上限(看了一下源码,PriorityBlockingQueue是对 PriorityQueue的再次包装,是基于堆数据结构
的,而PriorityQueue是没有容量限制
的,与ArrayList一样,所以在优先阻塞 队列上put时是不会受阻的
。虽然此队列逻辑上是无界
的,但是由于资源被耗尽,所以试图执行添加操作可能会导致 OutOfMemoryError
),但是如果队列为空,那么取元素的操作take就会阻塞
,所以它的检索操作take是受阻的。另外,往入该队列中的元 素要具有比较能力
DelayQueue
DelayQueue(基于PriorityQueue
来实现的)是一个存放Delayed 元素的无界阻塞队列
,只有在延迟
期满时才能从中提取元素。该队列的头部是延迟期满后保存时间最长的 Delayed 元素。如果延迟都还没有期满,则队列没有头部,并且poll
将返回null。当一个元素的 getDelay(TimeUnit.NANOSECONDS) 方法返回一个小于或等于零的值时,则出现期满,poll就以移除这个元素了。此队列不允许使用 null 元素。
初始状态
因为队列是没有边界的
,向队列中添加
元素的线程不会阻塞
,添加操作相对简单,所以此图不考虑向队列添加元素的生产者线程。假设现在共有三个消费者线程。
队列中的元素按到期时间排序,队列头部的元素2s以后到期。消费者线程1查看了头部元素以后,发现还需要2s才到期,于是它进入等待
状态,2s以后醒来,等待头部元素到期的线程称为Leader
线程。
消费者线程2与消费者线程3处于待命状态,它们不等待队列中的非头部元素。当消费者线程1拿到对象5以后,会向它们发送signal
。这个时候两个中的一个会结束待命状态而进入等待状态
2S以后
消费者线程1已经拿到了对象5,从等待状态进入处理状态,处理它取到的对象5,同时向消费者线程2与消费者线程3发送signal。
消费者线程2与消费者线程3会争抢领导权,这里是消费者线程2进入等待状态,成为Leader线程,等待2s以后对象4到期。而消费者线程3则继续处于待命状态。
此时队列中加入了一个新元素对象6,它10s后到期,排在队尾
又2S以后
先看线程1,如果它已经结束了对象5的处理,则进入待命状态。如果还没有结束,则它继续处理对象5。
消费线程2取到对象4以后,也进入处理状态,同时给处于待命状态的消费线程3发送信号,消费线程3进入等待状态,成为新的Leader。现在头部元素是新插入的对象7,因为它1s以后就过期,要早于其它所有元素,所以排到了队列头部
又1S后
一种不好的结果:
消费线程3一定正在处理对象7。消费线程1与消费线程2还没有处理完它们各自取得的对象,无法进入待命状态,也更加进入不了等待状态。此时对象3马上要到期,那么如果它到期时没有消费者线程空下来,则它的处理一定会延期。
可以想见,如果元素进入队列的速度很快,元素之间的到期时间相对集中,而处理每个到期元素的速度又比较慢的话,则队列会越来越大,队列后边的元素延期处理的时间会越来越长
另外一种好的结果:
消费线程1与消费线程2很快的完成对取出对象的处理,及时返回重新等待队列中的到期元素。一个处于等待状态(Leader),对象3一到期就立刻处理。另一个则处于待命状态。这样,每一个对象都能在到期时被及时处理,不会发生明显的延期。
所以,消费者线程的数量要够,处理任务的速度要快。否则,队列中的到期元素无法被及时取出并处理,造成任务延期、队列元素堆积等情况
示例代码:
DelayQueue的一个应用场景是定时任务调度。本例中先让主线程向DelayQueue添加10个任务,任务之间的启动间隔在1~2s之间,每个任务的执行时间固定为2s,代码如下:
package com.zhangdb.thread;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.DelayQueue;
import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
class DelayTask implements Delayed {
private static long currentTime = System.currentTimeMillis();
protected final String taskName;
protected final int timeCost;
protected final long scheduleTime;
protected static final AtomicInteger taskCount = new AtomicInteger(0);
// 定时任务之间的启动时间间隔在1~2s之间,timeCost表示处理此任务需要的时间,本示例中为2s
public DelayTask(String taskName, int timeCost) {
this.taskName = taskName;
this.timeCost = timeCost;
taskCount.incrementAndGet();
currentTime += 1000 + (long) (Math.random() * 1000);
scheduleTime = currentTime;
}
@Override
public int compareTo(Delayed o) {
return (int) (this.scheduleTime - ((DelayTask) o).scheduleTime);
}
@Override
public long getDelay(TimeUnit unit) {
long expirationTime = scheduleTime - System.currentTimeMillis();
return unit.convert(expirationTime, TimeUnit.MILLISECONDS);
}
public void execTask() {
long startTime = System.currentTimeMillis();
System.out.println("Task " + taskName + ": schedule_start_time=" + scheduleTime + ",real start time="
+ startTime + ",delay=" + (startTime - scheduleTime));
try {
Thread.sleep(timeCost);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
class DelayTaskComsumer extends Thread {
private final BlockingQueue<DelayTask> queue;
public DelayTaskComsumer(BlockingQueue<DelayTask> queue) {
this.queue = queue;
}
@Override
public void run() {
DelayTask task = null;
try {
while (true) {
task = queue.take();
task.execTask();
DelayTask.taskCount.decrementAndGet();
}
} catch (InterruptedException e) {
System.out.println(getName() + " finished");
}
}
}
public class DelayQueueExample {
public static void main(String[] args) {
BlockingQueue<DelayTask> queue = new DelayQueue<DelayTask>();
for (int i = 0; i < 10; i++) {
try {
queue.put(new DelayTask("work " + i, 2000));
} catch (InterruptedException e) {
e.printStackTrace();
}
}
ThreadGroup g = new ThreadGroup("Consumers");
for (int i = 0; i < 1; i++) {
new Thread(g, new DelayTaskComsumer(queue)).start();
}
while (DelayTask.taskCount.get() > 0) {
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
g.interrupt();
System.out.println("Main thread finished");
}
}
package org.dromara.hmily.demo.springcloud.account.service;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.concurrent.DelayQueue;
import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;
/**
* @description: 延时队列测试
* @author: hh
*/
public class DelayedQueneTest {
public static void main(String[] args) throws InterruptedException {
Item item1 = new Item("item1", 5, TimeUnit.SECONDS);
Item item2 = new Item("item2",10, TimeUnit.SECONDS);
Item item3 = new Item("item3",15, TimeUnit.SECONDS);
DelayQueue<Item> queue = new DelayQueue<>();
queue.put(item1);
queue.put(item2);
queue.put(item3);
System.out.println("begin time:" + LocalDateTime.now().format(DateTimeFormatter.ISO_LOCAL_DATE_TIME));
for (int i = 0; i < 3; i++) {
Item take = queue.take();
System.out.format("name:{%s}, time:{%s}\n",take.name, LocalDateTime.now().format(DateTimeFormatter.ISO_DATE_TIME));
}
}
}
class Item implements Delayed{
/* 触发时间*/
private long time;
String name;
public Item(String name, long time, TimeUnit unit) {
this.name = name;
this.time = System.currentTimeMillis() + (time > 0? unit.toMillis(time): 0);
}
@Override
public long getDelay(TimeUnit unit) {
return time - System.currentTimeMillis();
}
@Override
public int compareTo(Delayed o) {
Item item = (Item) o;
long diff = this.time - item.time;
if (diff <= 0) {// 改成>=会造成问题
return -1;
}else {
return 1;
}
}
@Override
public String toString() {
return "Item{" +
"time=" + time +
", name='" + name + '\'' +
'}';
}
}
测试结果
ConcurrentLinkedQueue(常用并发队列)
ConcurrentLinkedQueue 是 Queue 的一个安全实现。Queue 中元素按 FIFO 原则进行排序。采用 CAS
操作,来保证元素的一致性。
- boolean offer(E e): 在队尾插入元素,不进行阻塞
- E poll(): 取出并删除队列中的首元素,不进行阻塞
- E peek(): 取出第一个元素但是不删除它,不进行阻塞
- 并发队列ConcurrentLinkedQueue、阻塞队列AraayBlockingQueue、阻塞队列LinkedBlockingQueue 区别 和 使用场景总结
者 都是线程安全的。区别,就是 并发 和 阻塞,前者为并发队列,因为采用cas算法,所以能够高并发的处理;后2者采用锁机制,所以是阻塞的。
后2者区别:联系,第2和第3都是阻塞队列,都是采用锁,都有阻塞容器Condition,通过Condition阻塞容量为空时的取操作和容量满时的写操作第。
区别,第2就一个整锁,第3是2个锁,所以第2第3的锁机制不一样,第3比第2吞吐量 大,并发性能也比第2高