基于java中延时队列的实现该文章，我们这次主要是来实现基于DelayQueue实现的延时队列。
使用DelayQueue实现的延时队列的步骤：
- 定义一个继承了Delayed的类，定义其中的属性，并重写
compareTo和getDelay两个方法 - 创建一个
Delayqueue用于创建队列 - 创建一个生产者，用于将信息添加到队列中
- 创建一个消费者，用来从队列中取出信息进行消费
接下来是一个简单的demo ：
定义一个元素类
import lombok.Data;
import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;
@Data
public class DelayTesk implements Delayed {
//标签Id
private String uid;
//到期时间
private Long timestamp;
//延时信息
private String data;
@Override
public long getDelay(TimeUnit unit) {
long delayTime = timestamp - System.currentTimeMillis();
//将时间转换成毫秒（这边可转可不转，影响不大）
return unit.convert(delayTime, TimeUnit.MILLISECONDS);
}
@Override
public int compareTo(Delayed o) {
//针对任务的延时时间长短进行排序，把延时时间最短的放在前面
long differenceTime = this.getDelay(TimeUnit.MILLISECONDS) - o.getDelay(TimeUnit.MILLISECONDS);
return (int)differenceTime;
}
}
定义一个延时队列
import java.util.concurrent.DelayQueue;
public class DelayTaskQueue {
/**
* 这边使用单例模式进行创建，保证全局队列的唯一性
* 我这边使用的是双检索，双校验模式
*/
private volatile static DelayQueue<DelayTesk> delayTaskQueue;
private DelayTaskQueue(){
}
public static DelayQueue<DelayTesk> getDelayTaskQueue() {
if (delayTaskQueue == null) {
synchronized (DelayTaskQueue.class) {
if (delayTaskQueue == null) {
delayTaskQueue = new DelayQueue<>();
}
}
}
return delayTaskQueue;
}
}
创建一个延时队列的生产者
import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.DelayQueue;
//消息生产者
@Slf4j
public class DelayTeskQueueProducer {
/**
* 往延时队列中插入数据
* @param uid
* @param time
* @param data
*/
public static void setDelayQueue(String uid, Long time, String data) {
//创建队列
DelayQueue<DelayTesk> delayTaskQueue = DelayTaskQueue.getDelayTaskQueue();
//创建任务
DelayTesk delayTesk = new DelayTesk();
delayTesk.setUid(uid);
delayTesk.setTimestamp(time);
delayTesk.setData(data);
log.info("====================消息入队:{}===============", uid);
boolean res = delayTaskQueue.offer(delayTesk);
if (res) {
log.info("====================消息入队成功:{}===============", uid);
} else {
//如果消息入队失败这边可以写一个失败的回调函数
//例如将失败的消息存入数据库，写个定时任务对消息进行重写投递……
log.info("====================消息入队失败:{}===============", uid);
}
}
}
定义一个延时队列的消费者
import cn.hutool.core.util.IdUtil;
import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.DelayQueue;
@Slf4j
public class DelayTeskQueueConsumer {
public static void main(String[] args) {
for (int i = 0; i < 10 ; i++) {
DelayTeskQueueProducer.setDelayQueue(IdUtil.fastUUID(), System.currentTimeMillis() + i * 1000, "hello world" + i);
}
int index = 0;
DelayQueue<DelayTesk> delayTaskQueue = DelayTaskQueue.getDelayTaskQueue();
while (index < 10) {
try {
DelayTesk delayTesk = delayTaskQueue.take();
System.out.println(delayTesk.getData());
} catch (InterruptedException e) {
log.error("延时队列消费异常：{}", e.getMessage());
}
}
}
}
结果
在控控制台中每隔1秒打印一行数据
到这差不多我们的Demo就要结束了，不过可能有些同学会问，你这个消费者不是是写在mian方法里的，每次消费的时候都需要手动去调用这跟我直接用sleep函数实现的延时队列有啥区别呀
别急 这个只是个Demo嘛，如果需要使用在项目中可以写一个监听器去实时监听该延时队列
我这边暂时就只讲3种
Timer
通过timer定时定频率去获取DelayTaskQueue中的消息
import com.study.project.delay.DelayTaskQueue;
import com.study.project.delay.DelayTesk;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.DelayQueue;
/**
* 添加@Configuration 注解，自动注入实例对象，并由springboot 启动 定时器，执行任务。
*/
@Configuration
@Slf4j
public class DelayTeskQueueTimer {
@Bean
public void DelayTeskQueueTimer() {
log.info("====================监听开始====================");
final Timer timer = new Timer();
DelayQueue<DelayTesk> delayTaskQueue = DelayTaskQueue.getDelayTaskQueue();
timer.schedule(new TimerTask() {
@Override
public void run() {
try {
DelayTesk delayTesk = delayTaskQueue.take();
System.out.println(delayTesk.getData());
} catch (Exception e) {
log.error("延时队列消费异常：{}", e.getMessage());
}
}
//第一次执行是在当前时间的一秒之后，之后每隔一秒钟执行一次
},1000, 1000);
}
}
ConmandlineRunner
import com.study.project.delay.DelayTaskQueue;
import com.study.project.delay.DelayTesk;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.CommandLineRunner;
import org.springframework.context.annotation.Configuration;
import java.util.concurrent.DelayQueue;
/**
* Spring Boot应用程序在启动后，程序从容器中遍历实现了CommandLineRunner接口的实例并运行它们的run方法
*/
@Slf4j
@Configuration
public class DelayTeskQueueTimerCommandLineRunner implements CommandLineRunner {
@Override
public void run(String... args) {
log.info("====================CommandLineRunner监听开始====================");
DelayQueue<DelayTesk> delayTaskQueue = DelayTaskQueue.getDelayTaskQueue();
new Thread(() ->{
while (true) {
try {
DelayTesk delayTesk = delayTaskQueue.take();
System.out.println(delayTesk.getData());
} catch (Exception e) {
log.error("延时队列消费异常：{}", e.getMessage());
}
}
}).start();
}
}
ApplicationListener
该方法和ConmandlineRunner方法一样 都是在Spring Boot应用程序在启动后，对DelayQueue进行监听
import com.study.project.delay.DelayTaskQueue;
import com.study.project.delay.DelayTesk;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.ApplicationListener;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.event.ContextRefreshedEvent;
import java.util.concurrent.DelayQueue;
@Slf4j
@Configuration
public class DelayTeskQueueApplicationListener implements ApplicationListener<ContextRefreshedEvent> {
@Override
public void onApplicationEvent(ContextRefreshedEvent event) {
log.info("====================ApplicationListener监听开始====================");
DelayQueue<DelayTesk> delayTaskQueue = DelayTaskQueue.getDelayTaskQueue();
new Thread(() -> {
while (true) {
try {
DelayTesk delayTesk = delayTaskQueue.take();
System.out.println(delayTesk.getData());
} catch (Exception e) {
log.error("延时队列消费异常：{}", e.getMessage());
}
}
}).start();
}
}
当然监听的方法其实还有很多，不过同学们在实现队列的时候不要觉得实现了就好了，要去思考如何去保证数据的持久化，保证数据不会不会丢失