扫码关注官方微信

扫码下载APP
返回顶部
首页 > 资讯 > 后端开发 > Python >SpringBootEvent事件如何实现异步延迟执行
  • 209

0
分享到

SpringBootEvent事件如何实现异步延迟执行

SpringBootEvent事件异步延迟执行SpringBoot实现异步 2023-02-14 18:02:59 209人浏览 薄情痞子

Python 官方文档：入门教程 => 点击学习

摘要

目录SpringBoot Event 事件实现异步延迟执行使用它只需要三样东西总结springBoot Event 事件实现异步延迟执行 Spring的事件（Application

springBoot Event 事件实现异步延迟执行

Spring的事件（Application Event）非常好用，虽然有一点会出现代码污染，但是在做不使用其他框架来做异步的情况先，还是非常方便的。

使用它只需要三样东西

  • 自定义事件：继承 ApplicationEvent，创建一个你想传的数据的对象，会在监听器那边收到该对象。
  • 定义监听器，实现 ApplicationListener 或者通过 @EventListener 注解到方法上，两种方式都行，但是推荐使用@EventListener，只要参数是你写的继承ApplicationEvent的对象，就会自动找到执行方法。
  • 定义发布者，通过 ApplicationEventPublisher，自带的bean，不需要单独声明，直接@Autowired就能使用，主要只需要publishEvent方法。

但是有时候我需要做延时执行，自带的功能缺不支持，但是我发现ApplicationEvent对象里面有两个成员变量，source和timestamp，构造函数（@since 5.3.8）也提供了同时注入这两个变量数据。

   
    public ApplicationEvent(Object source, Clock clock) {
        super(source);
        this.timestamp = clock.millis();
    }

但是，看了说明timestamp只是标志执行的时间，并不是为了延迟执行，可惜了。

于是查了一些资料，找到java.util.concurrent.DelayQueue对象，jdk自带了延迟的队列对象，我们可以考虑利用自带的timestamp和延迟队列DelayQueue结合一起来实现，具体DelayQueue的使用请自行查询，非常的简单。

首先，继承的ApplicationEvent重新实现一下。

不单单要继承ApplicationEvent，还需要实现Delayed，主要是因为DelayQueue队列中必须是Delayed的实现类

import java.time.Clock;
import java.time.Duration;
import java.util.Date;
import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;
 
import org.springframework.context.ApplicationEvent;
 
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.extern.slf4j.Slf4j;
 
@Data
@EqualsAndHashCode(callSuper = false)
public class ApplicationDelayedEvent extends ApplicationEvent implements Delayed {
 
    private static final long serialVersionUID = 1L;
 
    public ApplicationDelayedEvent(Object source) {
        this(source, 0L);
    }
 
    public ApplicationDelayedEvent(Object source, long delaySeconds) {
        super(source, Clock.offset(Clock.systemDefaultZone(), Duration.ofSeconds(delaySeconds)));
    }
 
    @Override
    public int compareTo(Delayed o) {
        // 最好用NANOSECONDS，更精确，但是用处不大
        long delta = getDelay(TimeUnit.MILLISECONDS) - o.getDelay(TimeUnit.MILLISECONDS);
        return (int) delta;
    }
 
    @Override
    public long getDelay(TimeUnit unit) {
        // 最好用NANOSECONDS，更精确，但是用处不大，负数也会认为到时间了
        long millis = this.getTimestamp();
        long currentTimeMillis = System.currentTimeMillis();
        long sourceDuration = millis - currentTimeMillis;
        return unit.convert(sourceDuration, unit);
    }
}

多了两个必须实现的方法，compareTo是排序，应该是队列中的顺序。

getDelay是主要的方法，目的是归0的时候会从DelayQueue释放出来，当然那必须是NANOSECONDS级别的，我使用MILLISECONDS，就会出现负数，但也是可以的，也能释放出来。

另一个需要改的就是发布者，所以重新写一个ApplicationDelayEventPublisher

import java.time.ZonedDateTime;
import java.time.fORMat.DateTimeFormatter;
import java.util.concurrent.DelayQueue;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.stereotype.Component;
 
import lombok.extern.slf4j.Slf4j;
 
@Slf4j
@Component
public class ApplicationDelayEventPublisher implements ApplicationRunner {
 
    // ApplicationDelayedEvent需要import进来
    private DelayQueue<ApplicationDelayedEvent> delayQueue = new DelayQueue<>();
 
    @Autowired
    private ApplicationEventPublisher eventPublisher;
 
    @Autowired
    @Qualifier("watchTaskExecutor")
    private ThreadPoolTaskExecutor poolTaskExecutor;
 
    public void publishEvent(ApplicationDelayedEvent event) {
        boolean result = delayQueue.offer(event);
        log.info("加入延迟队列。。。。{}", result);
    }
 
    @Override
    public void run(ApplicationArguments args) throws Exception {
        poolTaskExecutor.execute(() -> watchThread());
    }
 
    private void watchThread() {
        while (true) {
            try {
                log.info("启动延时任务的监听线程。。。。");
                ApplicationDelayedEvent event = this.delayQueue.take();
                log.info("接收到延时任务执行。。。{}", ZonedDateTime.now().format(DateTimeFormatter.ISO_OFFSET_DATE_TIME));
                eventPublisher.publishEvent(event);
            } catch (InterruptedException e) {
                log.info("启动延时任务的监听线程关闭");
                this.delayQueue.clear();
                break;
            }
        }
    }
}

需要实现ApplicationRunner作为Spring Boot的启动时候运行的bean，目的就是开启监听线程，有事件到了执行时间take方法会得到数据，然后调用Spring原生的事件发布。

另外特别说明的就是监听线程不能随便创建，脱离了Spring容器的线程池会造成关闭服务的时候造成无法关闭的现象，所以建议还是自定义一个ThreadPoolTaskExecutor

    @Bean
    public ThreadPoolTaskExecutor watchTaskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(1);
        executor.setMaxPoolSize(1);
        executor.setQueueCapacity(1);
        executor.seTKEepAliveSeconds(60);
        executor.setThreadNamePrefix("watch_task_");
 
        // 线程池对拒绝任务的处理策略
//        ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常
//        ThreadPoolExecutor.DiscardPolicy：丢弃任务，但是不抛出异常。
//        ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面。
//        ThreadPoolExecutor.CallerRunsPolicy：由调用者处理该任务 。
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        // 初始化
        executor.initialize();
        return executor;
    }

最后就是接收事件，跟传统的接收是一样的，异步只需要在配置类上加上@EnableAsync注解就行了，然后在监听的方法上加@Async

import java.util.concurrent.ThreadPoolExecutor;
 
import javax.annotation.PostConstruct;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
 
import lombok.extern.slf4j.Slf4j;
 
@Slf4j
@Configuration
@EnableAsync
@ConditionalOnClass(ApplicationDelayEventPublisher.class)
public class DelayEventConfiguration {
 
    @PostConstruct
    public void init() {
        log.info("延迟Spring事件模块启动中。。。");
    }
    
    // 不能和监听线程放到一个线程池，不然无法执行
    @Bean
    public ThreadPoolTaskExecutor poolTaskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(3);
        executor.setMaxPoolSize(50);
        executor.setQueueCapacity(10000);
        executor.setKeepAliveSeconds(30);
        executor.setThreadNamePrefix("my_task_");
 
        // 线程池对拒绝任务的处理策略
//        ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常
//        ThreadPoolExecutor.DiscardPolicy：丢弃任务，但是不抛出异常。
//        ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面。
//        ThreadPoolExecutor.CallerRunsPolicy：由调用者处理该任务 。
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.AbortPolicy());
        // 初始化
        executor.initialize();
        return executor;
    }
    
    @Bean
    public ThreadPoolTaskExecutor watchTaskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(1);
        executor.setMaxPoolSize(1);
        executor.setQueueCapacity(1);
        executor.setKeepAliveSeconds(60);
        executor.setThreadNamePrefix("watch_task_");
 
        // 线程池对拒绝任务的处理策略
//        ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常
//        ThreadPoolExecutor.DiscardPolicy：丢弃任务，但是不抛出异常。
//        ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面。
//        ThreadPoolExecutor.CallerRunsPolicy：由调用者处理该任务 。
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        // 初始化
        executor.initialize();
        return executor;
    }
}

    @Async("poolTaskExecutor")
    @EventListener
    public void listenDelayEvent(ApplicationDelayedEvent event) {
        log.info("收到执行事件：{}", event.getSource());
    }

总结

以上为个人经验，希望能给大家一个参考，也希望大家多多支持编程网。

您可能感兴趣的文档:

--结束END--

本文标题: SpringBootEvent事件如何实现异步延迟执行

本文链接: https://lsjlt.com/news/196075.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com    QQ/279061341

猜你喜欢
  • SpringBootEvent事件如何实现异步延迟执行
    目录SpringBoot Event 事件实现异步延迟执行使用它只需要三样东西总结SpringBoot Event 事件实现异步延迟执行 Spring的事件（Application ...
    99+
    2023-02-14
    SpringBoot Event事件 异步延迟执行 SpringBoot实现异步
  • Java如何实现异步延迟队列
    这篇文章主要介绍“Java如何实现异步延迟队列”，在日常操作中，相信很多人在Java如何实现异步延迟队列问题上存在疑惑，小编查阅了各式资料，整理出简单好用的操作方法，希望对大家解答”Java如何实现异步延迟队列”的疑惑有所帮助！接下来，请跟...
    99+
    2023-07-05
  • 批处理如何实现延迟执行命令
    这篇文章将为大家详细讲解有关批处理如何实现延迟执行命令，小编觉得挺实用的，因此分享给大家做个参考，希望大家阅读完这篇文章后可以有所收获。2003的工具包里有个sleep.exe2、结合vbs实现的代码代码如下:echo.wscript.sl...
    99+
    2023-06-09
  • jQuery如何设置延迟执行？
    这篇文章将为大家详细讲解有关jQuery如何设置延迟执行？，小编觉得挺实用的，因此分享给大家做个参考，希望大家阅读完这篇文章后可以有所收获。jQuery 设置延迟执行 设置超时延迟 使用 setTimeout() 方法设置超时延迟，以毫秒为...
    99+
    2024-04-02
  • jQuery如何取消延迟执行？
    这篇文章将为大家详细讲解有关jQuery如何取消延迟执行？，小编觉得挺实用的，因此分享给大家做个参考，希望大家阅读完这篇文章后可以有所收获。jQuery 取消延迟执行 延迟函数 jQuery 中的 setTimeout() 和 setInt...
    99+
    2024-04-02
  • LINQ如何实现子查询和延迟执行编程
    这篇文章将为大家详细讲解有关LINQ如何实现子查询和延迟执行编程，小编觉得挺实用的，因此分享给大家做个参考，希望大家阅读完这篇文章后可以有所收获。LINQ子查询 LINQ子查询是一个包含了另外一个查询的Lambda表达式的查询. 以下的例子...
    99+
    2023-06-17
  • Spark延迟执行是如何工作的
    Spark延迟执行是指Spark在执行任务时，并不立即执行所有的转换操作，而是将它们保存在内存中，直到需要执行动作操作为止。这种延迟...
    99+
    2024-03-04
    Spark
  • java代码如何实现异步执行
    在Java中，可以使用多线程或者使用Java 8之后引入的CompletableFuture来实现异步执行。 使用多线程： Th...
    99+
    2023-10-25
    java
  • python 实现异步执行
    python 实现异步执行 网上看到个例子怎样利用 threading 模块实现异步执行，自己动手试了试，写了个装饰器的例子，很实用。 把 async 分离开，放到一个单独的模块中，就可以把它当成一个模块实用 分析一下，...
    99+
    2023-01-31
    python
  • 如何实现Spring Event(异步事件)
    目录一、叙述Spring的事件需要遵循如下流程Spring框架中事件二、上Demo示例1. pom文件2. 自定义一个事件继承ApplicationEvent3. 自定义一个监听器实...
    99+
    2023-02-14
    Spring Event Spring Event 异步事件 Spring异步事件
  • Laravel如何实现supervisor执行异步进程
    今天小编给大家分享一下Laravel如何实现supervisor执行异步进程的相关知识点，内容详细，逻辑清晰，相信大部分人都还太了解这方面的知识，所以分享这篇文章给大家参考一下，希望大家阅读完这篇文章后有所收获，下面我们一起来了解一下吧。问...
    99+
    2023-07-04
  • Java实现异步延迟队列的方法详解
    目录1.应用场景2.延时处理方式调研1.DelayQueue2.延迟队列mq3.定时任务4.redis5. 时间轮3.实现目标4.架构设计5.延迟组件实现方式1.实现原理2.消息结构...
    99+
    2023-03-22
    Java异步延迟队列 Java延迟队列
  • js实现让某个动作延迟几秒执行
    目录js让某个动作延迟几秒执行js延迟函数delay的使用js让某个动作延迟几秒执行 setTimeout(function (){                  $(butto...
    99+
    2024-04-02
  • 如何使用golang函数闭包进行延迟执行
    使用 go 中的闭包可以延迟函数执行，直到稍后某个特定时间。通过创建闭包并捕获其上下文的变量，函数可以在稍后被调用时仍然访问这些变量。 如何使用 Go 中的闭包进行延迟执行 闭包是一种...
    99+
    2024-04-23
    golang 延迟执行 函数闭包
  • Flask实现异步执行任务
    Flask 是 Python 中有名的轻量级同步 web 框架，在一些开发中，可能会遇到需要长时间处理的任务，此时就需要使用异步的方式来实现，让长时间任务在后台运行，先将本次请求的响...
    99+
    2024-04-02
  • 如何实现Redis延迟队列
    这期内容当中小编将会给大家带来有关如何实现Redis延迟队列，文章内容丰富且以专业的角度为大家分析和叙述，阅读完这篇文章希望大家可以有所收获。延迟队列，顾名思义它是一种带有延迟功能的消息队列。那么，是在什么...
    99+
    2024-04-02
  • Linq如何实现延迟加载
    小编给大家分享一下Linq如何实现延迟加载，相信大部分人都还不怎么了解，因此分享这篇文章给大家参考一下，希望大家阅读完这篇文章后大有收获，下面让我们一起去了解一下吧！Linq延迟加载在查询某对象时，实际上你只查询该对象。不会同时自动获取这个...
    99+
    2023-06-17
  • Redis如何实现延迟队列
    目录Redis实现延迟队列Redis延迟队列Redis实现延时队列的优化方案延时队列的应用延时队列的实现总结Redis实现延迟队列 Redis延迟队列 Redis 是通过有序集合（ZSet）的方式来实现延迟消息队列的，Z...
    99+
    2023-04-28
    Redis延迟队列 Redis实现延迟队列 Redis队列
  • redis延迟队列如何实现
    redis 延迟队列的实现采用有序集合，将任务以分数（时间戳）存储，定期检索已到期的任务，删除并执行。步骤如下：创建有序集合 delayed_queue，将任务以分数（时间戳）存储。检索...
    99+
    2024-06-12
    redis 键值对
  • PHP实现异步延迟消息队列的方法详解
    目录一、前言二、场景三、安装RabbitMQ延迟队列插件四、在Laravel框架中进行使用五、执行生产消息和消费消息一、前言 需求：电商秒杀场景中，如果用户下单10分钟未支付，需要进...
    99+
    2024-04-02
软考高级职称资格查询
热门wiki
近期文章
推荐阅读
热门问答
热门标签
编程网，编程工程师的家园，是目前国内优秀的开源技术社区之一，形成了由开源软件库、代码分享、资讯、协作翻译、讨论区和博客等几大频道内容，为IT开发者提供了一个发现、使用、并交流开源技术的平台。

  • 官方手机版

  • 微信公众号

  • 商务合作