⼀⼝⽓说出Java6种延时队列的实现⽅法（⾯试官也得服）
五⼀期间原计划是写两篇⽂章，看⼀本技术类书籍，结果这五天由于⾃律性过于差，禁不住各种诱惑，我连电脑都没打开过，计划完美宣告失败。所以在这能看出和⼤佬之间的差距，⼈家没⽩没夜的更⽂，⽐你优秀的⼈⽐你更努⼒，难以望其项背，真是让我⾃愧不如。
知耻⽽后勇，这不逼着⾃⼰⼜学起来了，个⼈⽐较喜欢⼀些实践类的东西，既学习到知识⼜能让技术落地，能搞出个demo最好，本来不知道该分享什么主题，好在最近项⽬紧急招⼈中，⽽我有幸做了回⾯试官，就给⼤家整理分享⼀道⾯试题：“如何实现延时队列？”。
下边会介绍多种实现延时队列的思路，⽂末提供有⼏种实现⽅式的github地址。其实哪种⽅式都没有绝对的好与坏，只是看把它⽤在什么业务场景中，技术这东西没有最好的只有最合适的。
⼀、延时队列的应⽤
什么是延时队列？顾名思义：⾸先它要具有队列的特性，再给它附加⼀个延迟消费队列消息的功能，也就是说可以指定队列中的消息在哪个时间点被消费。
延时队列在项⽬中的应⽤还是⽐较多的，尤其像电商类平台：
1、订单成功后，在30分钟内没有⽀付，⾃动取消订单
2、外卖平台发送订餐通知，下单成功后60s给⽤户推送短信。
3、如果订单⼀直处于某⼀个未完结状态时，及时处理关单，并退还库存
4、淘宝新建商户⼀个⽉内还没上传商品信息，将冻结商铺等
。。。。
上边的这些场景都可以应⽤延时队列解决。
⼆、延时队列的实现
我个⼈⼀直秉承的观点：⼯作上能⽤JDK⾃带API实现的功能，就不要轻易⾃⼰重复造轮⼦，或者引⼊三⽅中间件。⼀⽅⾯⾃⼰封装很容易出问题（⼤佬除外），再加上调试验证产⽣许多不必要的⼯作量；另⼀⽅⾯⼀旦接⼊三⽅的中间件就会让系统复杂度成倍的增加，维护成本也⼤⼤的增加。
1、DelayQueue 延时队列
JDK中提供了⼀组实现延迟队列的API，位于urrent包下DelayQueue。
DelayQueue是⼀个BlockingQueue（⽆界阻塞）队列，它本质就是封装了⼀个PriorityQueue（优先队
列），PriorityQueue内部使⽤完全⼆叉
堆（不知道的⾃⾏了解哈）来实现队列元素排序，我们在向DelayQueue队列中添加元素时，会给元素⼀个Delay（延迟时间）作为排序条件，队列中最⼩的元素会优先放在队⾸。队列中的元素只有到了Delay时间才允许从队列中取出。队列中可以放基本数据类型或⾃定义实体类，在存放基本数据类型时，优先队列中元素默认升序排列，⾃定义实体类就需要我们根据类属性值⽐较计算了。
先简单实现⼀下看看效果，添加三个order⼊队DelayQueue，分别设置订单在当前时间的5秒、10秒、15秒后取消。
要实现DelayQueue延时队列，队中元素要implements Delayed接⼝，这哥接⼝⾥只有⼀个getDelay⽅法，⽤于设置延期时间。Order类
中compareTo⽅法负责对队列中的元素进⾏排序。
public class Order implements Delayed {
/**
* 延迟时间
*/
@JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
private long time;
String name;
public Order(String name, long time, TimeUnit unit) {
this.name = name;
this.time = System.currentTimeMillis() + (time > 0 ? Millis(time) : 0);
}
@Override
public long getDelay(TimeUnit unit) {
return time - System.currentTimeMillis();
}
@Override
public int compareTo(Delayed o) {
Order Order = (Order) o;
long diff = this.time - Order.time;
if (diff <= 0) {
return -1;
} else {
return 1;
}
}
}
DelayQueue的put⽅法是线程安全的，因为put⽅法内部使⽤了ReentrantLock锁进⾏线程同步。DelayQueue还提供了两种出队的⽅法poll()和take()，poll()为⾮阻塞获取，没有到期的元素直接返回null；take()阻塞⽅式获取，没有到期的元素线程将会等待。
public class DelayQueueDemo {
public static void main(String[] args) throws InterruptedException {
Order Order1 = new Order("Order1", 5, TimeUnit.SECONDS);
Order Order2 = new Order("Order2", 10, TimeUnit.SECONDS);
Order Order3 = new Order("Order3", 15, TimeUnit.SECONDS);
DelayQueue<Order> delayQueue = new DelayQueue<>();
delayQueue.put(Order1);
delayQueue.put(Order2);
delayQueue.put(Order3);
System.out.println("订单延迟队列开始时间:" + w().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
while (delayQueue.size() != 0) {
/**
* 取队列头部元素是否过期
*/
Order task = delayQueue.poll();
if (task != null) {
System.out.format("订单:{%s}被取消, 取消时间:{%s}\n", task.name, w().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"))); }
Thread.sleep(1000);
}
}
}
上边只是简单的实现⼊队与出队的操作，实际开发中会有专门的线程，负责消息的⼊队与消费。
执⾏后看到结果如下，Order1、Order2、Order3分别在5秒、10秒、15秒后被执⾏，⾄此就⽤DelayQueue实现了延时队列。
订单延迟队列开始时间:2020-05-06 14:59:09
订单:{Order1}被取消, 取消时间:{2020-05-06 14:59:14}
订单:{Order2}被取消, 取消时间:{2020-05-06 14:59:19}
订单:{Order3}被取消, 取消时间:{2020-05-06 14:59:24}
2、Quartz 定时任务
Quartz⼀款⾮常经典任务调度框架，在Redis、RabbitMQ还未⼴泛应⽤时，超时未⽀付取消订单功能都是由定时任务实现的。定时任务它有⼀定的周期性，可能很多单⼦已经超时，但还没到达触发执⾏的时间点，那么就会造成订单处理的不够及时。
引⼊quartz框架依赖包
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-quartz</artifactId>
</dependency>
在启动类中使⽤@EnableScheduling注解开启定时任务功能。
@EnableScheduling
@SpringBootApplication
public class DelayqueueApplication {
public static void main(String[] args) {
SpringApplication.run(DelayqueueApplication.class, args);
}
编写⼀个定时任务，每个5秒执⾏⼀次。
@Component
public class QuartzDemo {
//每隔五秒
@Scheduled(cron = "0/5 * * * * ? ")
public void process(){
System.out.println("我是定时任务！");
}
}
3、Redis sorted set
Redis的数据结构Zset，同样可以实现延迟队列的效果，主要利⽤它的score属性，redis通过score来为集合中的成员进⾏从⼩到⼤的排序。
通过zadd命令向队列delayqueue中添加元素，并设置score值表⽰元素过期的时间；向delayqueue添加三个order1、order2、order3，分别
是10秒、20秒、30秒后过期。
zadd delayqueue 3 order3
消费端轮询队列delayqueue，将元素排序后取最⼩时间与当前时间⽐对，如⼩于当前时间代表已经过期移除key。
/**
* 消费消息
*/
public void pollOrderQueue() {
while (true) {
Set<Tuple> set = angeWithScores(DELAY_QUEUE, 0, 0);
String value = ((Tuple) Array()[0]).getElement();
int score = (int) ((Tuple) Array()[0]).getScore();
Calendar cal = Instance();
int nowSecond = (int) (TimeInMillis() / 1000);
if (nowSecond >= score) {
<(DELAY_QUEUE, value);
System.out.println(sdf.format(new Date()) + " removed key:" + value);
}
if (ard(DELAY_QUEUE) <= 0) {
System.out.println(sdf.format(new Date()) + " zset empty ");
return;
}
Thread.sleep(1000);
}
}
我们看到执⾏结果符合预期
2020-05-07 13:24:09 add finished.
2020-05-07 13:24:19 removed key:order1
2020-05-07 13:24:29 removed key:order2
2020-05-07 13:24:39 removed key:order3
2020-05-07 13:24:39 zset empty
4、Redis 过期回调
Redis的key过期回调事件，也能达到延迟队列的效果，简单来说我们开启监听key是否过期的事件，⼀旦key过期会触发⼀个callback 事件。
修改f⽂件开启notify-keyspace-events Ex
notify-keyspace-events Ex
Redis监听配置，注⼊Bean RedisMessageListenerContainer
@Configuration
public class RedisListenerConfig {
@Bean
RedisMessageListenerContainer container(RedisConnectionFactory connectionFactory) {
RedisMessageListenerContainer container = new RedisMessageListenerContainer();
container.setConnectionFactory(connectionFactory);
return container;
}
}
编写Redis过期回调监听⽅法，必须继承KeyExpirationEventMessageListener，有点类似于MQ的消息监听。
@Component
public class RedisKeyExpirationListener extends KeyExpirationEventMessageListener {
public RedisKeyExpirationListener(RedisMessageListenerContainer listenerContainer) {
super(listenerContainer);
}
@Override
public void onMessage(Message message, byte[] pattern) {
String expiredKey = String();
System.out.println("监听到key：" + expiredKey + "已过期");
}
}
到这代码就编写完成，⾮常的简单，接下来测试⼀下效果，在redis-cli客户端添加⼀个key并给定3s的过期时间。
set xiaofu 123 ex 3
在控制台成功监听到了这个过期的key。
监听到过期的key为：xiaofu
5、RabbitMQ 延时队列
利⽤RabbitMQ做延时队列是⽐较常见的⼀种⽅式，⽽实际上RabbitMQ⾃⾝并没有直接⽀持提供延迟队列功能，⽽是通过RabbitMQ消息队列的TTL和DXL这两个属性间接实现的。
先来认识⼀下TTL和DXL两个概念：
Time To Live(TTL) ：
TTL顾名思义：指的是消息的存活时间，RabbitMQ可以通过x-message-tt参数来设置指定Queue（队列）和Message（消息）上消息的存活时间，它的值是⼀个⾮负整数，单位为微秒。
RabbitMQ可以从两种维度设置消息过期时间，分别是队列和消息本⾝
设置队列过期时间，那么队列中所有消息都具有相同的过期时间。
设置消息过期时间，对队列中的某⼀条消息设置过期时间，每条消息TTL都可以不同。
如果同时设置队列和队列中消息的TTL，则TTL值以两者中较⼩的值为准。⽽队列中的消息存在队列中的时间，⼀旦超过TTL过期时间则成为Dead Letter（死信）。
Dead Letter Exchanges（DLX）
DLX即死信交换机，绑定在死信交换机上的即死信队列。RabbitMQ的Queue（队列）可以配置两个参数x-dead-letter-exchange和x-dead-letter-routing-key（可选），⼀旦队列内出现了Dead Letter（死信），则按照这两个参数可以将消息重新路由到另⼀个Exchange（交换机），让消息重新被消费。
x-dead-letter-exchange：队列中出现Dead Letter后将Dead Letter重新路由转发到指定exchange（交换机）。
x-dead-letter-routing-key：指定routing-key发送，⼀般为要指定转发的队列。
队列出现Dead Letter的情况有：
消息或者队列的TTL过期
队列达到最⼤长度
消息被消费端拒绝（ject or basic.nack）
下边结合⼀张图看看如何实现超30分钟未⽀付关单功能，我们将订单消息A0001发送到延迟队列order.delay.queue，并设置x-message-
tt消息存活时间为30分钟，当到达30分钟后订单消息A0001成为了Dead Letter（死信），延迟队列检测到有死信，通过配置x-dead-letter-exchange，将死信重新转发到能正常消费的关单队列，直接监听关单队列处理关单逻辑即可。
发送消息时指定消息延迟的时间
public void send(String delayTimes) {
redis五种数据结构// 设置延迟毫秒值
return message;
});
}
}
设置延迟队列出现死信后的转发规则
/**
* 延时队列
*/
@Bean(name = "order.delay.queue")
public Queue getMessageQueue() {
return QueueBuilder
.durable(RabbitConstant.DEAD_LETTER_QUEUE)
// 配置到期后转发的交换
.withArgument("x-dead-letter-exchange", "hange")
// 配置到期后转发的路由键
.withArgument("x-dead-letter-routing-key", "order.close.queue")
.build();
}
6、时间轮
前边⼏种延时队列的实现⽅法相对简单，⽐较容易理解，时间轮算法就稍微有点抽象了。kafka、netty都有基于时间轮算法实现延时队列，下边主要实践Netty的延时队列讲⼀下时间轮是什么原理。
先来看⼀张时间轮的原理图，解读⼀下时间轮的⼏个基本概念
wheel：时间轮，图中的圆盘可以看作是钟表的刻度。⽐如⼀圈round长度为24秒，刻度数为8，那么每⼀个刻度表⽰3秒。那么时间精
版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。
发表评论