新来个技术总监:谁再用Redis实现订单超时自动关闭,以后就不用来了!

Spring Boot 监听 Redis Key 定时任务 业务场景 我们以订单功能为例说明下: 生成订单后一段时间不支付订单会自动关闭。最简单的想法是设置定时任务轮询,但是每个订单的创建时间不一样,定时任务的规则无法设定,如果将定时任务执行的间隔设置的过短,太影响效率。 还有一种想法,在用户进入订单界面的时候,判断时间执行相关操作。方式可能有很多,在这里介绍一种监听 Redis 键值对过期时间来实现订单自动关闭。 实现思路 在生成订单时,向 Redis ... 阅读详情

点击上方“芋道源码”,选择“设为星标”

管她前浪,还是后浪?

能浪的浪,才是好浪!

每天 10:33 更新文章,每天掉亿点点头发...

源码精品专栏

 

来源:三友的java日记

1abac7ca0fb9db6a49495dda7fd26c17.jpeg


由于Redis具有过期监听的功能,于是就有人拿它来实现订单超时自动关闭的功能,但是这个方案并不完美。今天来聊聊11种实现订单超时自动关闭的方案,总有一种适合你!这些方案并没有绝对的好坏之分,只是适用场景的不大相同。

a70db000e7f47b6d27c13d4fc34b3e64.png

DelayQueue

DelayQueue是JDK提供的api,是一个延迟队列

9b676a10268ba6be1fc85bd94be713e5.png

DelayQueue泛型参数得实现Delayed接口,Delayed继承了Comparable接口。

0c2c482caf36f3c0f2d89a96d8622e0b.png

getDelay方法返回这个任务还剩多久时间可以执行,小于0的时候说明可以这个延迟任务到了执行的时间了。

compareTo这个是对任务排序的,保证最先到延迟时间的任务排到队列的头。

来个demo
@Getter
public class SanYouTask implements Delayed {

    private final String taskContent;

    private final Long triggerTime;

    public SanYouTask(String taskContent, Long delayTime) {
        this.taskContent = taskContent;
        this.triggerTime = System.currentTimeMillis() + delayTime * 1000;
    }

    @Override
    public long getDelay(TimeUnit unit) {
        return unit.convert(triggerTime - System.currentTimeMillis(), TimeUnit.MILLISECONDS);
    }

    @Override
    public int compareTo(Delayed o) {
        return this.triggerTime.compareTo(((SanYouTask) o).triggerTime);
    }

}

SanYouTask实现了Delayed接口,构造参数

  • taskContent:延迟任务的具体的内容

  • delayTime:延迟时间,秒为单位

测试

@Slf4j
public class DelayQueueDemo {

    public static void main(String[] args) {
        DelayQueue<SanYouTask> sanYouTaskDelayQueue = new DelayQueue<>();

        new Thread(() -> {
            while (true) {
                try {
                    SanYouTask sanYouTask = sanYouTaskDelayQueue.take();
                    log.info("获取到延迟任务:{}", sanYouTask.getTaskContent());
                } catch (Exception e) {
                }
            }
        }).start();

        log.info("提交延迟任务");
        sanYouTaskDelayQueue.offer(new SanYouTask("芋道源码5s", 5L));
        sanYouTaskDelayQueue.offer(new SanYouTask("芋道源码3s", 3L));
        sanYouTaskDelayQueue.offer(new SanYouTask("芋道源码8s", 8L));
    }
}

开启一个线程从DelayQueue中获取任务,然后提交了三个任务,延迟时间分为别5s,3s,8s。

测试结果:

bb45a9eacac769af3c720f1be5c90d44.png

成功实现了延迟任务。

实现原理
1845875ba346de475a79ce2b411e7490.png

offer方法在提交任务的时候,会通过根据compareTo的实现对任务进行排序,将最先需要被执行的任务放到队列头。

take方法获取任务的时候,会拿到队列头部的元素,也就是队列中最早需要被执行的任务,通过getDelay返回值判断任务是否需要被立刻执行,如果需要的话,就返回任务,如果不需要就会等待这个任务到延迟时间的剩余时间,当时间到了就会将任务返回。

基于 Spring Boot + MyBatis Plus + Vue & Element 实现的后台管理系统 + 用户小程序,支持 RBAC 动态权限、多租户、数据权限、工作流、三方登录、支付、短信、商城等功能

  • 项目地址:https://github.com/YunaiV/ruoyi-vue-pro

  • 视频教程:https://doc.iocoder.cn/video/

Timer

Timer也是JDK提供的api

先来demo
@Slf4j
public class TimerDemo {

    public static void main(String[] args) {
        Timer timer = new Timer();
        
        log.info("提交延迟任务");
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                log.info("执行延迟任务");
            }
        }, 5000);
    }

}

通过schedule提交一个延迟时间为5s的延迟任务

48d17983ff6c8b8dee5023c1d4cbf673.png
实现原理

提交的任务是一个TimerTask

public abstract class TimerTask implements Runnable {
    //忽略其它属性
    
    long nextExecutionTime;
}

TimerTask内部有一个nextExecutionTime属性,代表下一次任务执行的时间,在提交任务的时候会计算出nextExecutionTime值。

Timer内部有一个TaskQueue对象,用来保存TimerTask任务的,会根据nextExecutionTime来排序,保证能够快速获取到最早需要被执行的延迟任务。

在Timer内部还有一个执行任务的线程TimerThread,这个线程就跟DelayQueue demo中开启的线程作用是一样的,用来执行到了延迟时间的任务。

所以总的来看,Timer有点像整体封装了DelayQueue demo中的所有东西,让用起来简单点。

虽然Timer用起来比较简单,但是在阿里规范中是不推荐使用的,主要是有以下几点原因:

  • Timer使用单线程来处理任务,长时间运行的任务会导致其他任务的延时处理

  • Timer没有对运行时异常进行处理,一旦某个任务触发运行时异常,会导致整个Timer崩溃,不安全

基于 Spring Cloud Alibaba + Gateway + Nacos + RocketMQ + Vue & Element 实现的后台管理系统 + 用户小程序,支持 RBAC 动态权限、多租户、数据权限、工作流、三方登录、支付、短信、商城等功能

  • 项目地址:https://github.com/YunaiV/yudao-cloud

  • 视频教程:https://doc.iocoder.cn/video/

ScheduledThreadPoolExecutor

由于Timer在使用上有一定的问题,所以在JDK1.5版本的时候提供了ScheduledThreadPoolExecutor,这个跟Timer的作用差不多,并且他们的方法的命名都是差不多的,但是ScheduledThreadPoolExecutor解决了单线程和异常崩溃等问题。

来个demo
@Slf4j
public class ScheduledThreadPoolExecutorDemo {

    public static void main(String[] args) {
        ScheduledThreadPoolExecutor executor = new ScheduledThreadPoolExecutor(2, new ThreadPoolExecutor.CallerRunsPolicy());

        log.info("提交延迟任务");
        executor.schedule(() -> log.info("执行延迟任务"), 5, TimeUnit.SECONDS);
    }

}

结果

80e3f04b583231b774481d66651be7f4.png
实现原理

ScheduledThreadPoolExecutor继承了ThreadPoolExecutor,也就是继承了线程池,所以可以有很多个线程来执行任务。

ScheduledThreadPoolExecutor在构造的时候会传入一个DelayedWorkQueue阻塞队列,所以线程池内部的阻塞队列是DelayedWorkQueue。

cfb94158f256bbe3d5dadb934a8eb5c2.png

在提交延迟任务的时候,任务会被封装一个任务会被封装成ScheduledFutureTask对象,然后放到DelayedWorkQueue阻塞队列中。

6259b0c517dc6a036a3a5f3dd842dcee.pngScheduledFutureTask

ScheduledFutureTask实现了前面提到的Delayed接口,所以其实可以猜到DelayedWorkQueue会根据ScheduledFutureTask对于Delayed接口的实现来排序,所以线程能够获取到最早到延迟时间的任务。

当线程从DelayedWorkQueue中获取到需要执行的任务之后就会执行任务。

RocketMQ

RocketMQ是阿里开源的一款消息中间件,实现了延迟消息的功能。

RocketMQ延迟消息的延迟时间默认有18个等级。

5234c0fd213277c4ea5b2448e9dbb9c7.png

当发送消息的时候只需要指定延迟等级即可。如果这18个等级的延迟时间不符和你的要求,可以修改RocketMQ服务端的配置文件。

来个demo

依赖

<dependency>
    <groupId>org.apache.rocketmq</groupId>
    <artifactId>rocketmq-spring-boot-starter</artifactId>
    <version>2.2.1</version>
  
<!--web依赖-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <version>2.2.5.RELEASE</version>
</dependency>

配置文件

rocketmq:
  name-server: 192.168.200.144:9876 #服务器ip:nameServer端口
  producer:
    group: sanyouProducer

controller类,通过DefaultMQProducer发送延迟消息到sanyouDelayTaskTopic这个topic,延迟等级为2,也就是延迟时间为5s的意思。

@RestController
@Slf4j
public class RocketMQDelayTaskController {

    @Resource
    private DefaultMQProducer producer;

    @GetMapping("/rocketmq/add")
    public void addTask(@RequestParam("task") String task) throws Exception {
        Message msg = new Message("sanyouDelayTaskTopic", "TagA", task.getBytes(RemotingHelper.DEFAULT_CHARSET));
        msg.setDelayTimeLevel(2);
        // 发送消息并得到消息的发送结果,然后打印
        log.info("提交延迟任务");
        producer.send(msg);
    }

}

创建一个消费者,监听sanyouDelayTaskTopic的消息。

@Component
@RocketMQMessageListener(consumerGroup = "sanyouConsumer", topic = "sanyouDelayTaskTopic")
@Slf4j
public class SanYouDelayTaskTopicListener implements RocketMQListener<String> {

    @Override
    public void onMessage(String msg) {
        log.info("获取到延迟任务:{}", msg);
    }

}

启动应用,浏览器输入以下链接添加任务

http://localhost:8080/rocketmq/add?task=sanyou

测试结果:

0927773ca8b90f29b73d88cf49930063.png
实现原理
b3dd0c1ac6eb594c70e0ed0836a23cef.png

生产者发送延迟消息之后,RocketMQ服务端在接收到消息之后,会去根据延迟级别是否大于0来判断是否是延迟消息

  • 如果不大于0,说明不是延迟消息,那就会将消息保存到指定的topic中

  • 如果大于0,说明是延迟消息,此时RocketMQ会进行一波偷梁换柱的操作,将消息的topic改成SCHEDULE_TOPIC_XXXX中,XXXX不是占位符,然后存储。

在BocketMQ内部有一个延迟任务,相当于是一个定时任务,这个任务就会获取SCHEDULE_TOPIC_XXXX中的消息,判断消息是否到了延迟时间,如果到了,那么就会将消息的topic存储到原来真正的topic(拿我们的例子来说就是sanyouDelayTaskTopic)中,之后消费者就可以从真正的topic中获取到消息了。

9b44d9a618db866d67c641a7f9e8f7f3.png定时任务

RocketMQ这种实现方式相比于前面提到的三种更加可靠,因为前面提到的三种任务内容都是存在内存的,服务器重启任务就丢了,如果要实现任务不丢还得自己实现逻辑,但是RocketMQ消息有持久化机制,能够保证任务不丢失。

RabbitMQ

RabbitMQ也是一款消息中间件,通过RabbitMQ的死信队列也可以是先延迟任务的功能。

demo

引入RabbitMQ的依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
    <version>2.2.5.RELEASE</version>
</dependency>

配置文件

spring:
  rabbitmq:
    host: 192.168.200.144 #服务器ip
    port: 5672
    virtual-host: /

RabbitMQ死信队列的配置类,后面说原理的时候会介绍干啥的

@Configuration
public class RabbitMQConfiguration {
    
    @Bean
    public DirectExchange sanyouDirectExchangee() {
        return new DirectExchange("sanyouDirectExchangee");
    }

    @Bean
    public Queue sanyouQueue() {
        return QueueBuilder
                //指定队列名称,并持久化
                .durable("sanyouQueue")
                //设置队列的超时时间为5秒,也就是延迟任务的时间
                .ttl(5000)
                //指定死信交换机
                .deadLetterExchange("sanyouDelayTaskExchangee")
                .build();
    }

    @Bean
    public Binding sanyouQueueBinding() {
        return BindingBuilder.bind(sanyouQueue()).to(sanyouDirectExchangee()).with("");
    }

    @Bean
    public DirectExchange sanyouDelayTaskExchange() {
        return new DirectExchange("sanyouDelayTaskExchangee");
    }

    @Bean
    public Queue sanyouDelayTaskQueue() {
        return QueueBuilder
                //指定队列名称,并持久化
                .durable("sanyouDelayTaskQueue")
                .build();
    }

    @Bean
    public Binding sanyouDelayTaskQueueBinding() {
        return BindingBuilder.bind(sanyouDelayTaskQueue()).to(sanyouDelayTaskExchange()).with("");
    }

}

RabbitMQDelayTaskController用来发送消息,这里没指定延迟时间,是因为在声明队列的时候指定了延迟时间为5s

@RestController
@Slf4j
public class RabbitMQDelayTaskController {

    @Resource
    private RabbitTemplate rabbitTemplate;

    @GetMapping("/rabbitmq/add")
    public void addTask(@RequestParam("task") String task) throws Exception {
        // 消息ID,需要封装到CorrelationData中
        CorrelationData correlationData = new CorrelationData(UUID.randomUUID().toString());
        log.info("提交延迟任务");
        // 发送消息
        rabbitTemplate.convertAndSend("sanyouDirectExchangee", "", task, correlationData);
    }

}

启动应用,浏览器输入以下链接添加任务

http://localhost:8080/rabbitmq/add?task=sanyou

测试结果,成功实现5s的延迟任务

a1c0ad09827e9bac1361482be5b8c0a2.png
实现原理
1d869306154433bf0e8107854cadc1f4.png

整个工作流程如下:

  • 消息发送的时候会将消息发送到sanyouDirectExchange这个交换机上

  • 由于sanyouDirectExchange绑定了sanyouQueue,所以消息会被路由到sanyouQueue这个队列上

  • 由于sanyouQueue没有消费者消费消息,并且又设置了5s的过期时间,所以当消息过期之后,消息就被放到绑定的sanyouDelayTaskExchange死信交换机中

  • 消息到达sanyouDelayTaskExchange交换机后,由于跟sanyouDelayTaskQueue进行了绑定,所以消息就被路由到sanyouDelayTaskQueue中,消费者就能从sanyouDelayTaskQueue中拿到消息了

上面说的队列与交换机的绑定关系,就是上面的配置类所干的事。

其实从这个单从消息流转的角度可以看出,RabbitMQ跟RocketMQ实现有相似之处。

消息最开始都并没有放到最终消费者消费的队列中,而都是放到一个中间队列中,等消息到了过期时间或者说是延迟时间,消息就会被放到最终的队列供消费者消息。

只不过RabbitMQ需要你显示的手动指定消息所在的中间队列,而RocketMQ是在内部已经做好了这块逻辑。

除了基于RabbitMQ的死信队列来做,RabbitMQ官方还提供了延时插件,也可以实现延迟消息的功能,这个插件的大致原理也跟上面说的一样,延时消息会被先保存在一个中间的地方,叫做Mnesia,然后有一个定时任务去查询最近需要被投递的消息,将其投递到目标队列中。

监听Redis过期key

在Redis中,有个发布订阅的机制

b0b34b9e4882efad500dbf86a3c15ce3.png

生产者在消息发送时需要到指定发送到哪个channel上,消费者订阅这个channel就能获取到消息。图中channel理解成MQ中的topic。

并且在Redis中,有很多默认的channel,只不过向这些channel发送消息的生产者不是我们写的代码,而是Redis本身。这里面就有这么一个channel叫做__keyevent@<db>__:expired,db是指Redis数据库的序号。

当某个Redis的key过期之后,Redis内部会发布一个事件到__keyevent@<db>__:expired这个channel上,只要监听这个事件,那么就可以获取到过期的key。

所以基于监听Redis过期key实现延迟任务的原理如下:

  • 将延迟任务作为key,过期时间设置为延迟时间

  • 监听__keyevent@<db>__:expired这个channel,那么一旦延迟任务到了过期时间(延迟时间),那么就可以获取到这个任务

来个demo

Spring已经实现了监听__keyevent@*__:expired这个channel这个功能,__keyevent@*__:expired中的*代表通配符的意思,监听所有的数据库。

所以demo写起来就很简单了,只需4步即可

依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
    <version>2.2.5.RELEASE</version>
</dependency>

配置文件

spring:
  redis:
    host: 192.168.200.144
    port: 6379

配置类

@Configuration
public class RedisConfiguration {

    @Bean
    public RedisMessageListenerContainer redisMessageListenerContainer(RedisConnectionFactory connectionFactory) {
        RedisMessageListenerContainer redisMessageListenerContainer = new RedisMessageListenerContainer();
        redisMessageListenerContainer.setConnectionFactory(connectionFactory);
        return redisMessageListenerContainer;
    }

    @Bean
    public KeyExpirationEventMessageListener redisKeyExpirationListener(RedisMessageListenerContainer redisMessageListenerContainer) {
        return new KeyExpirationEventMessageListener(redisMessageListenerContainer);
    }

}

KeyExpirationEventMessageListener实现了对__keyevent@*__:expiredchannel的监听

b79e5af8a1acd3b052add13ad926614d.png

当KeyExpirationEventMessageListener收到Redis发布的过期Key的消息的时候,会发布RedisKeyExpiredEvent事件

aef1faada66f26b526c9a064d31eea4d.png

所以我们只需要监听RedisKeyExpiredEvent事件就可以拿到过期消息的Key,也就是延迟消息。

对RedisKeyExpiredEvent事件的监听实现MyRedisKeyExpiredEventListener

@Component
public class MyRedisKeyExpiredEventListener implements ApplicationListener<RedisKeyExpiredEvent> {

    @Override
    public void onApplicationEvent(RedisKeyExpiredEvent event) {
        byte[] body = event.getSource();
        System.out.println("获取到延迟消息:" + new String(body));
    }

}

代码写好,启动应用

之后我直接通过Redis命令设置消息,就没通过代码发送消息了,消息的key为sanyou,值为task,值不重要,过期时间为5s

set sanyou task 

expire sanyou 5

成功获取到延迟任务

73849abbf0ba06184019f52ad49e145a.png

虽然这种方式可以实现延迟任务,但是这种方式坑 比较多

任务存在延迟

Redis过期事件的发布不是指key到了过期时间就发布,而是key到了过期时间被清除之后才会发布事件。

而Redis过期key的两种清除策略,就是面试八股文常背的两种:

  • 惰性清除。当这个key过期之后,访问时,这个Key才会被清除

  • 定时清除。后台会定期检查一部分key,如果有key过期了,就会被清除

所以即使key到了过期时间,Redis也不一定会发送key过期事件,这就到导致虽然延迟任务到了延迟时间也可能获取不到延迟任务。

丢消息太频繁

Redis实现的发布订阅模式,消息是没有持久化机制,当消息发布到某个channel之后,如果没有客户端订阅这个channel,那么这个消息就丢了,并不会像MQ一样进行持久化,等有消费者订阅的时候再给消费者消费。

所以说,假设服务重启期间,某个生产者或者是Redis本身发布了一条消息到某个channel,由于服务重启,没有监听这个channel,那么这个消息自然就丢了。

消息消费只有广播模式

Redis的发布订阅模式消息消费只有广播模式一种。

所谓的广播模式就是多个消费者订阅同一个channel,那么每个消费者都能消费到发布到这个channel的所有消息。

d14d83ec4dc7c71d7f27548fdc508ee2.png

如图,生产者发布了一条消息,内容为sanyou,那么两个消费者都可以同时收到sanyou这条消息。

所以,如果通过监听channel来获取延迟任务,那么一旦服务实例有多个的话,还得保证消息不能重复处理,额外地增加了代码开发量。

接收到所有key的某个事件

这个不属于Redis发布订阅模式的问题,而是Redis本身事件通知的问题。

当监听了__keyevent@<db>__:expired的channel,那么所有的Redis的key只要发生了过期事件都会被通知给消费者,不管这个key是不是消费者想接收到的。

所以如果你只想消费某一类消息的key,那么还得自行加一些标记,比如消息的key加个前缀,消费的时候判断一下带前缀的key就是需要消费的任务。

Redisson的RDelayedQueue

Redisson他是Redis的儿子(Redis son),基于Redis实现了非常多的功能,其中最常使用的就是Redis分布式锁的实现,但是除了实现Redis分布式锁之外,它还实现了延迟队列的功能。

先来个demo

引入pom

<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson</artifactId>
    <version>3.13.1</version>
</dependency>

封装了一个RedissonDelayQueue类

@Component
@Slf4j
public class RedissonDelayQueue {

    private RedissonClient redissonClient;

    private RDelayedQueue<String> delayQueue;
    private RBlockingQueue<String> blockingQueue;

    @PostConstruct
    public void init() {
        initDelayQueue();
        startDelayQueueConsumer();
    }

    private void initDelayQueue() {
        Config config = new Config();
        SingleServerConfig serverConfig = config.useSingleServer();
        serverConfig.setAddress("redis://localhost:6379");
        redissonClient = Redisson.create(config);

        blockingQueue = redissonClient.getBlockingQueue("SANYOU");
        delayQueue = redissonClient.getDelayedQueue(blockingQueue);
    }

    private void startDelayQueueConsumer() {
        new Thread(() -> {
            while (true) {
                try {
                    String task = blockingQueue.take();
                    log.info("接收到延迟任务:{}", task);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }, "SANYOU-Consumer").start();
    }

    public void offerTask(String task, long seconds) {
        log.info("添加延迟任务:{} 延迟时间:{}s", task, seconds);
        delayQueue.offer(task, seconds, TimeUnit.SECONDS);
    }

}

这个类在创建的时候会去初始化延迟队列,创建一个RedissonClient对象,之后通过RedissonClient对象获取到RDelayedQueue和RBlockingQueue对象,传入的队列名字叫SANYOU,这个名字无所谓。

当延迟队列创建之后,会开启一个延迟任务的消费线程,这个线程会一直从RBlockingQueue中通过take方法阻塞获取延迟任务。

添加任务的时候是通过RDelayedQueue的offer方法添加的。

controller类,通过接口添加任务,延迟时间为5s

@RestController
public class RedissonDelayQueueController {

    @Resource
    private RedissonDelayQueue redissonDelayQueue;

    @GetMapping("/add")
    public void addTask(@RequestParam("task") String task) {
        redissonDelayQueue.offerTask(task, 5);
    }

}

启动项目,在浏览器输入如下连接,添加任务

http://localhost:8080/add?task=sanyou

静静等待5s,成功获取到任务。

c77657b75f9aa09afbc15ad2c052a85c.png
实现原理

如下是Redisson延迟队列的实现原理

e7252646b4636390ec60f7cb02e47573.png

SANYOU前面的前缀都是固定的,Redisson创建的时候会拼上前缀。

  • redisson_delay_queue_timeout:SANYOU,sorted set数据类型,存放所有延迟任务,按照延迟任务的到期时间戳(提交任务时的时间戳 + 延迟时间)来排序的,所以列表的最前面的第一个元素就是整个延迟队列中最早要被执行的任务,这个概念很重要

  • redisson_delay_queue:SANYOU,list数据类型,也是存放所有的任务,但是研究下来发现好像没什么用。。

  • SANYOU,list数据类型,被称为目标队列,这个里面存放的任务都是已经到了延迟时间的,可以被消费者获取的任务,所以上面demo中的RBlockingQueue的take方法是从这个目标队列中获取到任务的

  • redisson_delay_queue_channel:SANYOU,是一个channel,用来通知客户端开启一个延迟任务

任务提交的时候,Redisson会将任务放到redisson_delay_queue_timeout:SANYOU中,分数就是提交任务的时间戳+延迟时间,就是延迟任务的到期时间戳

Redisson客户端内部通过监听redisson_delay_queue_channel:SANYOU这个channel来提交一个延迟任务,这个延迟任务能够保证将redisson_delay_queue_timeout:SANYOU中到了延迟时间的任务从redisson_delay_queue_timeout:SANYOU中移除,存到SANYOU这个目标队列中。

于是消费者就可以从SANYOU这个目标队列获取到延迟任务了。

所以从这可以看出,Redisson的延迟任务的实现跟前面说的MQ的实现都是殊途同归,最开始任务放到中间的一个地方,叫做redisson_delay_queue_timeout:SANYOU,然后会开启一个类似于定时任务的一个东西,去判断这个中间地方的消息是否到了延迟时间,到了再放到最终的目标的队列供消费者消费。

Redisson的这种实现方式比监听Redis过期key的实现方式更加可靠,因为消息都存在list和sorted set数据类型中,所以消息很少丢。

Netty的HashedWheelTimer

先来个demo
@Slf4j
public class NettyHashedWheelTimerDemo {

    public static void main(String[] args) {
        HashedWheelTimer timer = new HashedWheelTimer(100, TimeUnit.MILLISECONDS, 8);
        timer.start();

        log.info("提交延迟任务");
        timer.newTimeout(timeout -> log.info("执行延迟任务"), 5, TimeUnit.SECONDS);
    }

}

测试结果

111d6336f412033a8b7fe31760810454.png
实现原理
2b3df2d3bea7c1c87487f65680c54af0.png

如图,时间轮会被分成很多格子(上述demo中的8就代表了8个格子),一个格子代表一段时间(上述demo中的100就代表一个格子是100ms),所以上述demo中,每800ms会走一圈。

当任务提交的之后,会根据任务的到期时间进行hash取模,计算出这个任务的执行时间所在具体的格子,然后添加到这个格子中,通过如果这个格子有多个任务,会用链表来保存。所以这个任务的添加有点像HashMap储存元素的原理。

HashedWheelTimer内部会开启一个线程,轮询每个格子,找到到了延迟时间的任务,然后执行。

由于HashedWheelTimer也是单线程来处理任务,所以跟Timer一样,长时间运行的任务会导致其他任务的延时处理。

前面Redisson中提到的客户端延迟任务就是基于Netty的HashedWheelTimer实现的。

Hutool的SystemTimer

Hutool工具类也提供了延迟任务的实现SystemTimer

demo
@Slf4j
public class SystemTimerDemo {

    public static void main(String[] args) {
        SystemTimer systemTimer = new SystemTimer();
        systemTimer.start();

        log.info("提交延迟任务");
        systemTimer.addTask(new TimerTask(() -> log.info("执行延迟任务"), 5000));
    }

}

执行结果

bfc6cd4f1f21bfe2830f91496e6c4a8c.png

Hutool底层其实也用到了时间轮。

Qurtaz

Qurtaz是一款开源作业调度框架,基于Qurtaz提供的api也可以实现延迟任务的功能。

demo

依赖

<dependency>
    <groupId>org.quartz-scheduler</groupId>
    <artifactId>quartz</artifactId>
    <version>2.3.2</version>
</dependency>

SanYouJob实现Job接口,当任务到达执行时间的时候会调用execute的实现,从context可以获取到任务的内容

@Slf4j
public class SanYouJob implements Job {
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        JobDetail jobDetail = context.getJobDetail();
        JobDataMap jobDataMap = jobDetail.getJobDataMap();
        log.info("获取到延迟任务:{}", jobDataMap.get("delayTask"));
    }
}

测试类

public class QuartzDemo {

    public static void main(String[] args) throws SchedulerException, InterruptedException {
        // 1.创建Scheduler的工厂
        SchedulerFactory sf = new StdSchedulerFactory();
        // 2.从工厂中获取调度器实例
        Scheduler scheduler = sf.getScheduler();

        // 6.启动 调度器
        scheduler.start();

        // 3.创建JobDetail,Job类型就是上面说的SanYouJob
        JobDetail jb = JobBuilder.newJob(SanYouJob.class)
                .usingJobData("delayTask", "这是一个延迟任务")
                .build();

        // 4.创建Trigger
        Trigger t = TriggerBuilder.newTrigger()
                //任务的触发时间就是延迟任务到的延迟时间
                .startAt(DateUtil.offsetSecond(new Date(), 5))
                .build();

        // 5.注册任务和定时器
        log.info("提交延迟任务");
        scheduler.scheduleJob(jb, t);
    }
}

执行结果:

752cec8a551ca11337447ae4c82604c2.png
实现原理

核心组件

  • Job:表示一个任务,execute方法的实现是对任务的执行逻辑

  • JobDetail:任务的详情,可以设置任务需要的参数等信息

  • Trigger:触发器,是用来触发业务的执行,比如说指定5s后触发任务,那么任务就会在5s后触发

  • Scheduler:调度器,内部可以注册多个任务和对应任务的触发器,之后会调度任务的执行

40693231cc2aa099d5b83caa7a308925.png

启动的时候会开启一个QuartzSchedulerThread调度线程,这个线程会去判断任务是否到了执行时间,到的话就将任务交给任务线程池去执行。

无限轮询延迟任务

无限轮询的意思就是开启一个线程不停的去轮询任务,当这些任务到达了延迟时间,那么就执行任务。

demo
@Slf4j
public class PollingTaskDemo {

    private static final List<DelayTask> DELAY_TASK_LIST = new CopyOnWriteArrayList<>();

    public static void main(String[] args) {
        new Thread(() -> {
            while (true) {
                try {
                    for (DelayTask delayTask : DELAY_TASK_LIST) {
                        if (delayTask.triggerTime <= System.currentTimeMillis()) {
                            log.info("处理延迟任务:{}", delayTask.taskContent);
                            DELAY_TASK_LIST.remove(delayTask);
                        }
                    }
                    TimeUnit.MILLISECONDS.sleep(100);
                } catch (Exception e) {
                }
            }
        }).start();

        log.info("提交延迟任务");
        DELAY_TASK_LIST.add(new DelayTask("芋道源码", 5L));
    }

    @Getter
    @Setter
    public static class DelayTask {

        private final String taskContent;

        private final Long triggerTime;

        public DelayTask(String taskContent, Long delayTime) {
            this.taskContent = taskContent;
            this.triggerTime = System.currentTimeMillis() + delayTime * 1000;
        }
    }

}

任务可以存在数据库又或者是内存,看具体的需求,这里我为了简单就放在内存里了。

执行结果:

19d49ee05368805a344681b93c6f57ea.png

这种操作简单,但是就是效率低下,每次都得遍历所有的任务。

最后

最后,本文所有示例代码地址:

https://github.com/sanyou3/delay-task-demo.git


欢迎加入我的知识星球,一起探讨架构,交流源码。加入方式,长按下方二维码噢:

ee39eb5be0d42d2b750c91d453a818df.png

已在知识星球更新源码解析如下:

d22f54490005600b6cac682c054a4b49.jpeg

37aa9ff3a6e2f359d68b53d72fb599ea.jpeg

fe4b743cec902a99d13d9d1ccd5d4fb1.jpeg

6455d48bfc4eb28bf1e3d3d37e7a3799.jpeg

最近更新《芋道 SpringBoot 2.X 入门》系列,已经 101 余篇,覆盖了 MyBatis、Redis、MongoDB、ES、分库分表、读写分离、SpringMVC、Webflux、权限、WebSocket、Dubbo、RabbitMQ、RocketMQ、Kafka、性能测试等等内容。

提供近 3W 行代码的 SpringBoot 示例,以及超 4W 行代码的电商微服务项目。

获取方式:点“在看”,关注公众号并回复 666 领取,更多内容陆续奉上。

文章有帮助的话,在看,转发吧。
谢谢支持哟 (*^__^*)
SpringBoot+Redis实现订单超时自动取消方案 延时任务是分布式系统中的常见需求,通过预设触发时间实现异步业务逻辑。其核心技术原理包括时间轮算法、消息队列延迟投递和Redis有序集合等实现方式,能有效解决电商场景下的库存占用和交易公平性问题。以订单超时自动取消为例,结合Redis ZSET结构实现的延迟队列具有高性能和分布式优势,通过score排序和定期扫描机制确保任务准时触发。该方案在SpringBoot工程实践中需注意大key优化、消息可靠性保障等生产级问题,适用于需要精确控制任务执行时间的支付超时、优惠券过期等业务场景。 阅读详情

相关推荐

上线前夜爆出致命Bug?资深测试总监的「危机决策树」曝光

凌晨三点,咖啡见底,突然发现一个可能让服务器雪崩的Bug——这是每个测试人的噩梦。经历过7次重大上线战役的血泪教训,我总结出这套价值百万的「五阶决策模型」,教你用架构师思维化解上线危机。记住:每一次危机都是展示你全局视野的机会——那些在上线烽火中沉淀的方法论,终将成为你职业晋升的核弹头。A. 按时上线:热修复+10倍监控+预备200%客服人力(推荐)C. 砍功能上线:临时关闭秒杀模块(影响GMV -7%)- 资金风险:可能造成超卖损失(概率0.37%)Pod的OOMKilled次数(每小时>3次回滚)

海姐软件测试的博客 836

如何用Redis实现延迟队列

虽然基于MQ这个方式走不通了,但是这个项目中使用到Redis,所以我就想是否能够使用Redis来代替MQ实现延迟队列的功能,于是我就查了一下有没有现成可用的方案,别说,还真给我查到了两种方案,并且我还仔细研究对比了这两个方案,发现要想很好的实现延迟队列,并不简单。到这我终于明白了,上面的例子中即使我设置了5s的过期时间,但是当5s过去之后,只要两种清除策略都不满足,没人访问sanyou这个key,后台的定时清理的任务也没扫描到sanyou这个key,那么就不会发布key过期的事件,自然而然也就监听不到了。

xiaocai 6856

秒杀:少卖问题(图解+秒懂+史上最全)

本文深入解析秒杀场景中的少卖问题,通过图解和实战案例揭示库存冻结未释放的技术诱因,并提供五套解决方案,包括延迟消息补偿、定时任务扫描等,帮助电商平台优化秒杀系统,避免利润流失。重点解决秒杀与超卖的核心矛盾,提升库存管理效率。

weixin_32821533的博客 347

基于Redis订单未支付30分钟自动取消

基于Redis订单未支付30分钟自动取消

Gblfy_Blog 2712

真实工程中的非典型学习:从故障断点反向构建技术能力

在现代软件工程中,‘学习’早已脱离教科书式的线性路径,演变为以业务故障为起点、多维度交织的网状认知重构过程。其核心原理在于:知识不是按学科分层积累,而是在真实系统压力下,围绕具体问题(如超时异常、连接池耗尽)逆向拼合协议层、数据层、架构层等技术子集。这种‘断点回溯’式实践,显著提升问题定位效率与技术决策准确性,支撑高并发、强一致、可观测等关键场景落地。尤其适用于自学者突破‘学而不用’瓶颈、新工程师接手遗留系统、技术负责人验证架构选型——当SocketTimeoutException和Redis连接池耗尽成为

weixin_34195142的博客 581

技术人十年成长路径:从写代码到定义问题的三次跃迁

软件工程师的成长,本质是从‘工具使用者’向‘系统构建者’演进的过程。它始于对基础编程能力的掌握,深化于对操作系统、网络、数据库等底层原理的理解,其技术价值在于将抽象知识转化为解决真实故障与业务瓶颈的确定性能力。典型应用场景包括线上事故快速定位、高并发系统权衡设计、跨职能需求本质挖掘等。这一过程高度依赖问题驱动的学习机制、可验证的知识沉淀和面向协作的技术表达——正如文中反复强调的‘画依赖图’‘算经济账’‘给财务讲备份’,正是技术人突破CRUD瓶颈、建立不可替代性的关键跃迁。

diaozhiwa5526的博客 369

订单超时未支付自动取消5种实现方案

在开发中,往往会遇到一些关于延时任务的需求。比如最近大家都在忙抢回家的火车票,当你下了一个订单没有支付时,会有一个倒计时,提示你半小时之内支付,否则会自动取消。这样的场景是如何实现的呢?

m0_73311735的博客 1634

零基础搭建AI Agent:5步实现职场自动化闭环

AI Agent 是一种具备感知、决策、执行与记忆能力的智能体,其核心原理在于将大模型与工具调用、状态管理、结构化输出相结合,形成可闭环的任务执行系统。相比传统提示工程或RAG检索增强,Agent 更强调真实业务动作的端到端完成,技术价值体现在稳定性、可调试性与工作流嵌入能力。典型应用场景包括销售日报自动生成、HR入职流程同步、电商库存预警等高频重复任务。本文聚焦‘第一个可用Agent’的落地路径,以飞书机器人+MySQL+本地JSON记忆为技术栈,通过目标锚定、感官装配、决策中枢、记忆缓存、交互入口五步法

hwpokay的专栏 422

炸锅!应用暴力关闭丢了 200 万订单,Bean 乱序初始化毁了整库数据!Spring 优雅方案拯救你的系统

更要命的是,恢复数据时发现,缓存初始化 Bean 比数据库连接 Bean 先启动,导致缓存加载的全是脏数据,整库数据校验失败。此时可实现Ordered接口,指定初始化顺序。更严重的是,某支付系统因PaymentBean比EncryptionBean(加密 Bean)先初始化,导致首批支付数据用 “空密钥” 加密,解密时全成了乱码,直接损失 300 万。控制 Bean 的初始化 / 销毁顺序,本质是解决 “依赖前置” 问题:确保 A Bean 在 B Bean 之后初始化,因为 A 需要 B 的初始化结果。

赵KK的博客 566

用 Heroku 免费实现数据科学自动化任务调度

数据科学自动化本质是将本地脚本升级为稳定、可调度、可观测的生产级服务。其核心原理在于进程生命周期管理与环境隔离,而非单纯部署代码;技术价值体现在降低运维门槛、保障执行确定性、规避本地依赖风险;典型应用场景包括定时数据采集、模型轻量推理、邮件/消息推送、异常监控告警等;Heroku Hobby Dyno 以零配置、免绑卡、进程级热启动等特性,成为个人及中小团队实现 Python 数据任务自动化的高性价比选择。

weixin_30617737的博客 525

大疆智图002:大疆智图倾斜摄影建模流程

本文主要介绍大疆智图倾斜摄影建模流程,包括新建工程、成果路径设置、导入照片、第一遍空三、像控刺点、第二遍空三、精度报告查看、三维重建等流程。

qq_31762031的博客 1万+

CEO、CTO、VP、总监、Head、PM……到底谁最大?

很多人在互联网公司工作三五年,依然分不清 CEO、CTO、VP、总监、Head、PM、PO、BA、项目经理之间到底有什么区别,也不知道测试、开发、架构师、AI工程师、HRBP分别负责什么。这篇文章从组织架构、职责边界、权力范围、汇报关系、职业发展等多个维度出发,系统梳理互联网公司的职位体系与权力结构,覆盖高管层、管理层、产品体系、研发体系、测试体系、数据体系、AI岗位及HR体系。帮助新人快速建立职场认知,也帮助有经验的从业者重新理解组织运转逻辑与职业发展路径。

这里是技术“军火商”的前哨站。不制造焦虑,不空谈概念,只提供能直接解决你项目痛点的“军火”与“急救包”。关注我,一起变强! 1651

从CAD到完美网格:HyperMesh几何清理全流程指南(2023最新版)

本文详细介绍了2023最新版HyperMesh在几何清理和网格划分方面的全流程操作指南。从CAD导入、几何修复到中面提取和网格生成,系统性地分享了实战验证的解决方案,帮助工程师高效处理复杂几何体,提升有限元模型质量。特别针对汽车和航空航天领域的常见问题,提供了智能化工具和优化技巧。

weixin_29306011的博客 228

互联网大厂Java面试实录:水货程序员谢飞机的三面惊魂记(Spring Boot/Redis/微服务深度解析)

谢飞机在面试中,基础概念回答准确,但复杂问题细节掌握不足,比如Seata流程、Redis分布式锁缺陷等。整体表现符合“水货程序员”定位,简单问题能回答,复杂问题含糊其辞。

qq_55902281的博客 764

Dify 从入门到精通:第一篇 - 基础介绍与快速上手

Dify是一个开源的低代码平台,旨在简化大型语言模型(LLM)应用的开发流程。本文作为"Dify从入门到精通"系列的首篇,全面介绍了Dify的核心概念、安装步骤和基本使用方法。文章首先解析了Dify的多模型支持、低代码开发等特点,然后详细讲解了基于Docker的安装配置过程,包括系统要求、环境变量设置等。通过创建一个邮件助手应用的实际示例,展示了Dify的可视化工作流设计功能。最后简要介绍了高级特性和最佳实践,为后续深入学习奠定基础。本文为开发者提供了从零开始使用Dify构建AI应用的完

IT深耕十余载,大道之简 1153

centos7部署mysql8.0.35,主从复制,主主集群

centos7 linux部署mysql,主从复制,主主模式

zaixiaqin的博客 1992

大厂Java面试实录:从Redis高并发到Spring AI与RAG架构,谢飞机的渡劫之旅

本文以搞笑程序员谢飞机的大厂面试为场景,深度解析Redis缓存、Kafka消息队列、微服务熔断及Spring AI与RAG架构在电商智能客服中的应用,附详细技术解答,适合Java开发者学习。

weixin_49030345的博客 212

C# chart以鼠标所在位置为中心进行缩放

以前都用labview做一些软件,但给出去总是会遇到版本,安装包过大等一些问题,于是想自学C#,记录一下使用过程中遇到的一些问题和解决措施,便于日后回顾。 在这个项目中需要绘制折线图,由于数据比较大,需要对图表进行缩放操作,以鼠标为中心对图表进行缩放,在网上查找了一些资料没找到我想要的,于是自己想了一个解决方案,可以基本实现,但略显繁琐,由于刚开始学习C#,对一些操作不太了解,若以后遇...

fei的博客 6364

网易Java后端面试实录:三轮技术面考点与复盘

Java后端开发不仅要求扎实的语言基础,更需要对JVM内存模型、并发编程、MySQL索引与事务等底层原理有深入理解。而高并发场景下的缓存设计、分布式锁与消息队列应用,则是大厂面试中高频考察的实战能力。从HashMap扩容机制到Redis原子操作,从秒杀系统的事务一致性到实时榜单的系统设计,技术面试始终围绕“原理-实践-权衡”的逻辑展开。掌握这些核心知识,不仅有助于通过面试,更能支撑真实业务中的架构决策。本文以一个双非本科生成功拿下网易Java后端offer的完整经历为线索,逐一复盘一面基础、二面项目与场景设

weixin_34055787的博客 388

利用大规模生物活性挖掘,计算识别针对癌基因驱动蛋白 EGFR、BRAF 与 CDK4 的高亲和力抑制剂

背景:精准癌症治疗需要小分子抑制剂与致瘤蛋白靶点之间的精确匹配。方法:我们使用 Python 及 ChEMBL 数据库 API 开发了一套计算流程,系统性地筛选针对 EGFR、BRAF 与 CDK4 的高亲和力配体。对 IC50 < 1000 nM 的生物活性进行过滤,并检索候选化合物的分子结构(SMILES)以供后续优化。结果:本研究共识别出 [插入总数] 种独特化合物。其中,对 BRAF 激酶而言,我们挑选了一批 IC50 低至 6.0 nM 的高效实验性化合物。

u012133341的博客 97

第12步 支持向量机(SVM)

搭建SVM

Jet4505的博客 1052

模板驱动文档自动化:零代码实现数据填充与批量生成

文档自动化是企业提效降错的关键技术路径,其核心在于将固定结构与动态数据解耦。模板驱动模式通过可视化定义文档骨架(如标题、条款、表格框架),结合字段标签(如{{client_name}})实现精准数据填充,无需编程即可完成PDF/Word批量生成。相比AI生成易出错、代码渲染难维护的局限,该方案以高确定性、强合规性和低使用门槛,广泛应用于合同、报价单、对账单等标准化文档场景,尤其适合市场、销售、法务、HR等非技术人员快速落地。

439

多思计组实验实验三、存储器读写实验

实验三、存储器读写实验

qq_53089329的博客 3653

3-way Match多维建模:用xarray实现财务对账自动化

3-way Match(三单匹配)是企业采购对账的核心业务逻辑,本质是PO、GRN与Invoice在时间、物料、订单等多维度下的语义一致性校验。传统二维表处理难以表达‘一对多对多’关系和时序约束,导致漏判误判频发。多维数据建模通过引入PO_ID、Item_ID、Timestamp、Doc_Type四正交维度,将业务规则转化为可广播的张量运算,显著提升匹配准确率与差异归因深度。xarray凭借原生N维支持、坐标索引与稀疏存储能力,成为高可靠财务自动化场景下的关键技术选型。本文聚焦从财务制度到布尔矩阵的规则翻译

weixin_34199405的博客 352

霍尼韦尔SoftMaster使用说明

霍尼韦尔SoftMaster使用说明

假人有限元模型

假人模型,车辆碰撞假人有限元模型,适合做乘员安全的研究者利用

模板驱动型文档自动化:零代码实现结构化文档智能生成

文档自动化是企业提升运营效率的关键技术路径,其核心在于将重复性、结构化、高确定性的文档生产从人工操作升级为数据驱动的智能流程。它基于模板引擎原理,通过变量绑定、条件逻辑、循环渲染与动态样式等能力,实现数据到文档的精准映射。相比AI生成易出幻觉、低代码平台配置复杂,模板驱动方案以‘数据可信、逻辑可控、变更即时’为技术价值,在销售报价、合同管理、HR入职、财务单据等高频场景中显著降低错误率、压缩处理时间、释放专业人力。本文聚焦Sqribble平台实践,详解如何构建可维护、可审计、可集成的模板驱动型文档自动化系统

weixin_30706691的博客 505

老版QQ原生表情gif动态

这是老版的QQ表情,不过全是动态的的,Windows照片查看器是不会动的,可以右击用浏览器打开查看,再说一遍是老版的,只是分享给宁愿用老版也要动态的人。

测试工程师的三维生存坐标系:业务、技术与协同

软件测试的本质是保障系统在真实业务场景下的可靠性与一致性。其核心不在于执行用例的数量,而在于对业务逻辑的深度理解、对技术实现的准确解码、以及在跨职能协作中推动质量共识的能力。具备业务穿透力,才能识别需求背后的规则断层;掌握HTTP协议、SQL验证和Git溯源等关键技术支点,方能构建技术共生性;通过标准化交叉测试、契约测试、缺陷信息熵定义等机制,则可夯实组织协同基础。这些能力共同构成测试人在自动化浪潮与组织变革中的职业反脆弱性,也是当前行业高频搜索‘软件测试核心能力’‘测试工程师转型路径’所指向的真实答案。

374

VC中sqlite的使用

在VC中对sqlite的使用,实现数据库大批数据的快速插入,读取数据库中的数据在ListCtrl中显示

上一篇: 被问烂的Redis分布式锁,你真的懂了?
下一篇: 阿里又开源一款数据同步工具 DataX,稳定又高效,好用到爆!
公众号-芋道源码
博客等级 码龄10年 1640粉丝 377原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值