共计 8558 个字符,预计需要花费 22 分钟才能阅读完成。
一、延时队列的利用
什么是延时队列?顾名思义:首先它要具备队列的个性,再给它附加一个提早生产队列音讯的性能,也就是说能够指定队列中的音讯在哪个工夫点被生产。
延时队列在我的项目中的利用还是比拟多的,尤其像电商类平台:
1、订单胜利后,在 30 分钟内没有领取,主动勾销订单
2、外卖平台发送订餐告诉,下单胜利后 60s 给用户推送短信。3、如果订单始终处于某一个未完结状态时,及时处理关单,并退还库存
4、淘宝新建商户一个月内还没上传商品信息,将解冻商铺等。。。。
上边的这些场景都能够利用延时队列解决。
二、延时队列的实现
我集体始终秉承的观点:工作上能用 JDK
自带 API
实现的性能,就不要轻易本人反复造轮子,或者引入三方中间件。一方面本人封装很容易出问题(大佬除外),再加上调试验证产生许多不必要的工作量;另一方面一旦接入三方的中间件就会让零碎复杂度成倍的减少,保护老本也大大的减少。
1、DelayQueue 延时队列
JDK
中提供了一组实现提早队列的 API
,位于Java.util.concurrent
包下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 ? unit.toMillis(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("订单提早队列开始工夫:" + LocalDateTime.now().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, LocalDateTime.now().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 = jedis.zrangeWithScores(DELAY_QUEUE, 0, 0);
String value = ((Tuple) set.toArray()[0]).getElement();
int score = (int) ((Tuple) set.toArray()[0]).getScore();
Calendar cal = Calendar.getInstance();
int nowSecond = (int) (cal.getTimeInMillis() / 1000);
if (nowSecond >= score) {jedis.zrem(DELAY_QUEUE, value);
System.out.println(sdf.format(new Date()) + "removed key:" + value);
}
if (jedis.zcard(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 事件。
批改 redis.conf
文件开启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 = message.toString();
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
过期 - 队列达到最大长度
- 音讯被生产端回绝(basic.reject 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) {
amqpTemplate.convertAndSend("order.pay.exchange", "order.pay.queue","大家好我是提早数据", message -> {
// 设置提早毫秒值
message.getMessageProperties().setExpiration(String.valueOf(delayTimes));
return message;
});
}
}
设置提早队列呈现死信后的转发规定
/**
* 延时队列
*/
@Bean(name = "order.delay.queue")
public Queue getMessageQueue() {
return QueueBuilder
.durable(RabbitConstant.DEAD_LETTER_QUEUE)
// 配置到期后转发的替换
.withArgument("x-dead-letter-exchange", "order.close.exchange")
// 配置到期后转发的路由键
.withArgument("x-dead-letter-routing-key", "order.close.queue")
.build();}
6、工夫轮
前边几种延时队列的实现办法绝对简略,比拟容易了解,工夫轮算法就略微有点形象了。kafka
、netty
都有基于工夫轮算法实现延时队列,下边次要实际 Netty
的延时队列讲一下工夫轮是什么原理。
先来看一张工夫轮的原理图,解读一下工夫轮的几个基本概念
wheel
:工夫轮,图中的圆盘能够看作是钟表的刻度。比方一圈round
长度为24 秒
,刻度数为 8
,那么每一个刻度示意 3 秒
。那么工夫精度就是 3 秒
。工夫长度 / 刻度数值越大,精度越大。
当增加一个定时、延时 工作 A
,假如会提早 25 秒
后才会执行,可工夫轮一圈 round
的长度才24 秒
,那么此时会依据工夫轮长度和刻度失去一个圈数 round
和对应的指针地位 index
,也是就 工作 A
会绕一圈指向 0 格子
上,此时工夫轮会记录该工作的 round
和 index
信息。当 round=0,index=0,指针指向 0 格子
工作 A
并不会执行,因为 round= 0 不满足要求。
所以每一个格子代表的是一些工夫,比方 1 秒
和25 秒
都会指向 0 格子上,而工作则放在每个格子对应的链表中,这点和HashMap
的数据有些相似。
Netty
构建延时队列次要用 HashedWheelTimer
,HashedWheelTimer
底层数据结构仍然是应用DelayedQueue
,只是采纳工夫轮的算法来实现。
上面咱们用 Netty
简略实现延时队列,HashedWheelTimer
构造函数比拟多,解释一下各参数的含意。
ThreadFactory
:示意用于生成工作线程,个别采纳线程池;tickDuration
和unit
:每格的工夫距离,默认 100ms;ticksPerWheel
:一圈下来有几格,默认 512,而如果传入数值的不是 2 的 N 次方,则会调整为大于等于该参数的一个 2 的 N 次方数值,有利于优化hash
值的计算。
public HashedWheelTimer(ThreadFactory threadFactory, long tickDuration, TimeUnit unit, int ticksPerWheel) {this(threadFactory, tickDuration, unit, ticksPerWheel, true);
}
TimerTask
:一个定时工作的实现接口,其中 run 办法包装了定时工作的逻辑。Timeout
:一个定时工作提交到Timer
之后返回的句柄,通过这个句柄内部能够勾销这个定时工作,并对定时工作的状态进行一些根本的判断。Timer
:是HashedWheelTimer
实现的父接口,仅定义了如何提交定时工作和如何进行整个定时机制。
public class NettyDelayQueue {public static void main(String[] args) {final Timer timer = new HashedWheelTimer(Executors.defaultThreadFactory(), 5, TimeUnit.SECONDS, 2);
// 定时工作
TimerTask task1 = new TimerTask() {public void run(Timeout timeout) throws Exception {System.out.println("order1 5s 后执行");
timer.newTimeout(this, 5, TimeUnit.SECONDS);// 完结时候再次注册
}
};
timer.newTimeout(task1, 5, TimeUnit.SECONDS);
TimerTask task2 = new TimerTask() {public void run(Timeout timeout) throws Exception {System.out.println("order2 10s 后执行");
timer.newTimeout(this, 10, TimeUnit.SECONDS);// 完结时候再注册
}
};
timer.newTimeout(task2, 10, TimeUnit.SECONDS);
// 提早工作
timer.newTimeout(new TimerTask() {public void run(Timeout timeout) throws Exception {System.out.println("order3 15s 后执行一次");
}
}, 15, TimeUnit.SECONDS);
}
}
从执行的后果看,order3
、order3
延时工作只执行了一次,而 order2
、order1
为定时工作,依照不同的周期反复执行。
order1 5s 后执行
order2 10s 后执行
order3 15s 后执行一次
order1 5s 后执行
order2 10s 后执行
作者:程序员内点事
链接:https://juejin.im/post/684490…
起源:掘金
著作权归作者所有。商业转载请分割作者取得受权,非商业转载请注明出处。