阻塞队列和定时器的使用
阻塞队列
谈到队列,大家就能想到队列的先进先出原则,但有些特殊的队列,虽然也是先进先出的,但是带有阻塞功能,我们把这种队列叫做阻塞队列.
★如果队列为空,执行出队操作就会阻塞,阻塞到另外一个线程往队列里添加元素(队列不为空)为止.
★如果队列满了,执行入队操作时,也会阻塞,阻塞到另外一个线程从队列里取出元素(队列不满).
想要了解阻塞队列,先了解生产者-消费者模型,这个模型给我们程序带来了非常重要的好处
1.生产者-消费者模型
在一个餐馆中，有多名厨师（生产者）负责烹饪菜品，并将其放在共享的出菜区（缓冲区）上。而服务员（消费者）则从出菜区上取出菜品并端给顾客。这里的厨师可以看作是生产者，出菜区是缓冲区，服务员是消费者。
1. 实现了生产者和消费者之间的 "解耦"
我们写代码要追求低耦合,所谓解耦操作,就是降低耦合的过程.
比如过年一家人一起包饺子. 一般都是有明确分工 , 比如一个人负责擀饺子皮 , 其他人负责包 . 擀饺 子皮的人就是 "生产者", 包饺子的人就是 " 消费者 ".擀饺子皮的人不关心包饺子的人是谁( 能包就行 , 无论是手工包 , 借助工具 , 还是机器包 ), 包饺子的人 也不关心擀饺子皮的人是谁( 有饺子皮就行 , 无论是用擀面杖擀的 , 还是拿罐头瓶擀 , 还是直接从超市买的)
2.可以"削峰填谷",保证系统的稳定性
阻塞队列就相当于一个缓冲区,平衡了生产者消费者的处理能力
比如在 " 秒杀 " 场景下 , 服务器同一时刻可能会收到大量的支付请求 . 如果直接处理这些支付请求 , 服务器可能扛不住( 每个支付请求的处理都需要比较复杂的流程 ). 这个时候就可以把这些请求都放 到一个阻塞队列中, 然后再由消费者线程慢慢的来处理每个支付请求 .这样做可以有效进行 " 削峰 ", 防止服务器被突然到来的一波请求直接冲垮
2.标准库中的阻塞队列
java标准库中内置了阻塞队列,在使用的时候直接使用标准库中的就行
1.BlockingDeque是一个接口
2.真正实现BlockingDeque的类有三种
3.带有阻塞功能的方法.put()方法用于阻塞队列的入队,take()方法用于阻塞队列的出队.在使用take的时候需要处理异常
public static void main(String[] args) {
BlockingQueue blockingQueue = new LinkedBlockingQueue<>();
//创建两个线程,来作为生产者和消费者
Thread customer = new Thread(() -> {
while (true) {
try {
Integer result = blockingQueue.take();
System.out.println("消费元素: " + result);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
customer.start();
Thread producer = new Thread( () -> {
int count = 0;
while (true) {
try {
blockingQueue.put(count);
System.out.println("生产元素: " + count );
count++;
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
producer.start();
} 上面执行的结果是
上面代码先执行消费元素是因为当customer线程执行到blockingQueue,take()时发生了阻塞,等到producer线程执行blockingQueue.put()后,两个线程并发执行,谁先打印都有可能.
4. 不带阻塞功能的方法 入队列 offer(), 出队列 poll(), 取队首元素 peek().
3.模拟实现阻塞队列
实现阻塞队列的前提是我们要先实现一个普通的队列,实现普通队列的方法有两种,一个是基于链表的队列,采用头删法和尾插法实现一个阻塞队列,另外一个方法是基于数组的循环队列,两个方法的具体实现在下面这篇文章里面.
循环队列的实现.
要模拟实现阻塞队列,前提是在多线程的基础上,通过synchronized关键字对put()和take()方法中的代码进行加锁,然后通过wait()和notify()方法对插入元素和取出元素进行阻塞等待.具体方法是,当插入元素时如果队列满了,就产生阻塞等待,直到有元素取出后唤醒put中的wait().当取出元素的时候,如果队列为空,让take()方法产生阻塞等待,只到有元素插入后,唤醒take()中的wait().
class MyBlockingQueue {
private int[] item = new int[1000];
private int head = 0;
private int tail = 0;
private int size = 0;
//插入元素
public void put(int value) throws InterruptedException {
synchronized (this) {
while(size == item.length) {
//队列满了,产生阻塞等待
this.wait();
}
item[tail] = value;
tail++;
if(tail >= item.length) {
tail = 0;
}
size++;
//唤醒take中的wait()
this.notify();
}
}
//取出元素
public Integer take() throws InterruptedException {
int result = 0;
synchronized (this) {
while(size == 0) {
//队列为空,产生阻塞等待
this.wait();
}
result = item[head];
head++;
if(head >= item.length) {
head = 0;
}
size--;
//唤醒put中的wait()
this.notify();
}
return result;
}
}定时器
定时器就好比是我们生活中的闹钟,当我们被早八的闹钟叫醒后想在床上在躺十分钟,我们设置闹钟就可以让十分钟再响,而我们的计时器具有类似的功能,是指定一段之间后执行一段代码.
在Java的标准库中有一个Timer类,Timer类的核心方法是schedule()
schedule()中有连个参数,第一个参数指定定时器要执行的任务,第二个参数指定多长时间后执行这个任务
模拟实现定时器
主要实现下面几种功能
1.让被注册的任务,能在指定时间后执行.为了实现这个功能可以单独在定时器内部建一个线程,让这个线程周期性的扫描,判断任务时间是否到了,如果到了,就执行,若没动,就继续等待.这n个任务,可以用优先级队列来保存,按照指定时间小的优先级高,就放在队头,此时扫描线程,就只需要扫描队头元素,对头元素时间没到的话,其他时间更不可能到.
在优先级队列中,我们是基于时间进行比较的,可以实现 Comparable接口来进行比较
在扫描线程中会出现下面的bug.
2.一个定时器可以指定N个任务,N个任务会按照指定时间按顺序执行.
具体实现代码
class MyTask implements Comparable{
//要执行的任务
private Runnable runnable;
//任务在什么时间执行(用毫秒时间戳表示)
private long time;
public MyTask(Runnable runnable, long time) {
this.runnable = runnable;
this.time = time;
}
//获取当前任务的时间
public long getTime() {
return time;
}
//执行任务
public void run() {
runnable.run();
}
@Override
public int compareTo(MyTask o) {
return (int) (this.time - o.time);
}
}
//定时器
class MyTimer {
//扫描线程
private Thread t = null;
//有一个阻塞优先级队列
private PriorityBlockingQueue queue = new PriorityBlockingQueue<>();
public MyTimer() {
t = new Thread(() -> {
while (true) {
try {
synchronized (this) {
MyTask myTask = queue.take();
//取出队头元素观察判断是否到时间了
long curTime = System.currentTimeMillis();
if(curTime < myTask.getTime()) {
//时间没到放回队列
queue.put(myTask);
} else {
//时间到了,执行任务
myTask.run();
this.wait(myTask.getTime() - curTime);
}
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
} );
t.start();
}
public void schedule (Runnable runnable,long after) {
//第一个参数 是指定的任务
// 第二个参数是在多少毫秒后执行
MyTask myTask = new MyTask(runnable,System.currentTimeMillis()+ after);
//把任务放到队列里
queue.put(myTask);
synchronized (this) {
this.notify();
}
}