scheduled线程池ScheduledExecutorService只执行一次_有个定时任务突然不执行了

最新推荐文章于 2025-10-19 20:53:26 发布
转载 最新推荐文章于 2025-10-19 20:53:26 发布 · 1.5k 阅读 · 0 ·
CC 4.0 BY-SA版权
原文链接：https://blog.youkuaiyun.com/weixin_39837207/article/details/111298518

本文探讨ScheduledExecutorService线程池在执行定时任务时可能遇到的问题，如因异常导致任务停止执行及执行时间超过周期间隔时的行为。文章强调了正确处理异常的重要性，并提醒开发者注意线程池调度机制。

scheduled线程池ScheduledExecutorService只执行一次_有个定时任务突然不执行了

原因

If any execution of the task encounters an exception, subsequent executions are suppressed. Otherwise, the task will only terminate via cancellation or termination of the executor. If any execution of this task takes longer than its period, then subsequent executions may start late, but will not concurrently execute.

如果任务的任何一次执行遇到异常，则将禁止后续执行。其他情况下，任务将仅通过取消操作或终止线程池来停止。

如果某一次的执行时间超过了任务的间隔时间，后续任务会等当前这次执行结束才执行。

这个方法的注释，已经告诉我们了在使用这个方法的时候，要注意的事项了。

要注意发生异常时，任务终止的情况。
要注意定时任务调度会等待正在执行的任务结束，才会发起下一轮调度，即使超过了间隔时间。
这里说一句，线程池的使用中，注释真的十分关键，把坑说的很清楚。(mdzz，说了那么多你自己还不是没看??)

原文链接：https://blog.youkuaiyun.com/weixin_39837207/article/details/111298518

 

Java-什么是定时任务线程池？
兴趣是最好的老师
08-21 409
创建定时任务线程池：使用 Executors.newScheduledThreadPool() 方法创建一个定时任务线程。提交任务：使用 scheduleAtFixedRate 方法提交任务到线程池，该任务每隔一秒执行一次。提交任务：使用 scheduleAtFixedRate 方法提交任务到线程池，该任务每隔一秒执行一次。关闭线程池：使用 shutdown 方法关闭线程池，并等待所有任务完成。下面是一个使用上述工具类创建定时任务线程池并执行任务的示例。建定时任务线程池，这里设置了线程池大小为 3。
Java定时任务不再执行的原因与解决办法
lucyLee的博客
01-20 6998
try-catch。
JDK1.8源码分析：ScheduledExecutorService和周期性任务停止执行的原因
源码之下，了无秘密
02-16 6866
概述 ScheduledExecutorService继承于ExecutorService，主要提供任务的延迟和周期性执行的功能。其主要提供了schedule，scheduleAtFixedRate，scheduleWithFixedDelay三个方法，分别用于延迟执行任务，特定频率周期性执行任务，特定延迟周期性执行任务。 public interface ScheduledExecutorS...
Spring Boot 定时任务 @Scheduled
武培轩
10-17 1858
项目开发中经常需要执行一些定时任务，比如在每天凌晨，需要从 implala 数据库拉取产品功能活跃数据，分析处理后存入到 MySQL 数据库中。类似这样的需求还有许多，那么怎么去实现定时任务呢，有以下几种实现方式。 Java 定时任务的几种实现方式 基于 java.util.Timer 定时器，实现类似闹钟的定时任务 使用 Quartz、elastic-job、xxl-job 等开源第三方定时任...
ScheduledExecutorService
最新发布
Mark Wu 的博客
10-19 1266
本文介绍了Java的ScheduledExecutorService定时任务线程池的用法，包括三种核心方法：schedule（单次执行）、scheduleAtFixedRate（固定频率，可能堆积）和scheduleWithFixedDelay（固定间隔，更稳定）。重点对比了后两种方法的差异，并提供了Java和Kotlin的代码示例。文章还总结了最佳实践：异常处理、线程管理、生命周期控制等，并针对任务堆积问题提出了两种解决方案（改用固定间隔或跳过忙时任务）。最后指出在Android开发中可根据场景选择协程或
JUC学习
Lipeaun的博客
03-10 481
狂神说JUC 文章目录狂神说JUC线程和进程并发与并行线程状态wait/sleepsynchronizedlock虚假唤醒（notify All（））condition8锁死锁的必要条件callable辅助类(高并发必会)1.CountDownLatch 减法计数器2.CyclickBarrier 栅栏3.Semaphore 信号量锁升级读写锁 **ReadWriteLock**阻塞队列1.BlockQueue2.SynchronousQueue线程池(重点)1）线程池：好处2）线程池：三大方法3）线程池：
scheduled只执行一次_升级@Scheduled-分布式定时任务
weixin_39738667的博客
11-29 825
最近我在对项目的定时任务服务升级，希望改造成分布式，原本是利用@Scheduled注解实现，然而它并不支持分布式，如果改成quartz或者Spring Cloud Task，感觉对于自己这个简单的项目也没有必要。因此，我准备手写一个简单的支持分布式定时调度任务的框架。项目地址是https://github.com/death00/dis-schedule，欢迎大家star、提意见。分析先分析了一下...
使用ScheduledExecutorService实现异步几分钟后执行且只执行一次
09-08 3068
ScheduledExecutorService executorService = new ScheduledThreadPoolExecutor(1, new BasicThreadFactory.Builder().namingPattern("example-schedule-pool-%d").daemon(true).build()); executorService.schedule(new Runnable() { @Override public void.
解决SpirngBoot使用@Scheduled开启多个定时任务偶发任务不执行问题
weixin_44976835的博客
09-06 1677
在项目中需要配置定时任务采集hdfs-jmx数据进行读写数据库操作，还需要配置一些定时任务做告警操作，使用了@Scheduled注解。 在配置了7个按照运行结束时间每5s一次的定时任务时，发现了一个问题，就是有的定时任务没有按时执行，但是却又不是每一次都不执行，也不是每一次都是同一个线程不执行，很奇怪，去看了一下是怎么回事 项目中配置的部分定时任务代码如下： @Scheduled(fixedDelay = 5000) public void updateTotalDifference() t
计划执行任务ScheduledExecutorService，定时延迟线程执行
hlm2016的博客
09-15 1203
ScheduledExecutorService线程执行计划服务，创建对应的线程池，通过向线程池队列添加计划执行的线程，设置执行计划的延迟时间，然后开启计划服务即可间隔执行计划的线程。无返回结果的执行计划线程；有返回结果的执行计划线程；使用计划执行任务ScheduledExecutorService实现窗体拖动。
SpringBoot中并发定时任务的实现、动态定时任务的实现（看这一篇就够了）推荐
08-26
- `Timer`：是JDK提供的一个基础定时调度类，适合简单的按频率执行的任务，功能较为有限。 - `ScheduledExecutorService`：基于线程池设计，支持并发执行任务，适合处理并发需求，但调度功能较弱。 2. **Spring ...
scheduledexecutorservice 只执行一次_ScheduledExecutorService原理分析
weixin_39800971的博客
11-27 2440
最近跟别人聊天，别人问我了一个问题ScheduledExecutorService的原理是啥呢？说实话，一脸懵逼的就过去了，虽然知道这么个东西，说实话也没细看实现的原理，今天就来分析一下吧。我们先从一段代码开始今天的旅程。ScheduledExecutorService scheduledExecutorService = new ScheduledThreadPoolExecutor(1);这里...
scheduledexecutorservice 只执行一次_一个ScheduledExecutorService启动的Java线程无故挂掉引发的思考...
weixin_39782752的博客
12-06 1642
2018年12月12日18:44:53案件现场不久前，在开发改造公司一个端到端监控日志系统的时候，出现了一个bug：有个扫表写日志的线程无故挂掉。顺藤摸瓜我看了很久的代码，都没有想出来有什么地方有逻辑问题。万金油的方法是，重启。当我满心欢喜地认为重启是个好方法的时候，问题又重现了。我有点无奈地看着自己的代码 本我：堪称完美的逻辑，还有什么地方是我没有注意到的吗？ 真我：当然有了，你这个菜鸟，你不知...
线程池之ScheduledThreadPoolExecutor
weixin_34082854的博客
05-06 989
1. ScheduledThreadPoolExecutor简介 ScheduledThreadPoolExecutor可以用来在给定延时后执行异步任务或者周期性执行任务，相对于任务调度的Timer来说，其功能更加强大，Timer只能使用一个后台线程执行任务，而ScheduledThreadPoolExecutor则可以通过构造函数来指定后台线程的个数。ScheduledThreadPoolEx...
Java ScheduledThreadPoolExecutor 指定时间执行一次
深度
01-16 2553
文档 https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/ScheduledExecutorService.html 我也是醉了... 源码没有注释 , 官网才有.... 下面是示例 , 我的写法是不规范的 , 只是为了表现出如何使用 ScheduledThreadPoolExecutor schedule...
解决Spring boot Scheduled定时任务只执行了一次问题
u012214157的博客
02-04 2106
【代码】解决Spring boot Scheduled定时任务只执行了一次问题。
SSM框架中使用@Scheduled定时器，只想执行一次
易的博客
04-26 5122
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.data.redis.core.RedisTemplate; import org.springframework.stereotype.Service; import java.util.concurrent.TimeUnit; @Service public class RedisUtil { @Autowired..
使用ScheduledThreadPoolExecutor定时线程池执行任务，只执行一次
weixin_42426976的博客
05-30 1381
ScheduledThreadPoolExecutor定时线程池执行任务，只执行一次
scheduled只执行一次_记一次线程等待引起的bug解决过程
weixin_39958138的博客
12-02 372
1. 记一次线程等待引起的bug解决过程1.1. 问题使用Springboot的Scheduled注解框架执行定时任务，发现线上突然不打任何日志了，我们要找到它不打日志的原因1.2. 导出堆栈信息我们使用的是阿里的k8s服务，其实哪里都一样，进到对应容器的里，导出堆栈信息jps 或 top找到执行java程序的pidjstack -l pid > out.dump然后退出容器后，使用dock...
springboot控制定时任务只执行一次
08-20
<think>我们参考了用户提供的引用内容，特别是引用[1][2][4]中关于Spring Boot定时任务的介绍。用户的需求是：在Spring Boot应用中控制定时任务只执行一次。 解决方案分析： 在Spring Boot中，通常使用`@Scheduled`注解来创建定时任务。但是，标准的`@Scheduled`注解支持`cron`、`fixedRate`、`fixedDelay`等属性，这些属性都会导致任务重复执行。如果希望任务只执行一次，我们可以采用以下两种方法： 方法一：使用`@Scheduled`的`initialDelay`属性，并设置一个足够长的延迟时间（比如几年），这样在应用运行期间任务只会执行一次。但这种方法不够优雅，且如果应用重启，任务可能会再次执行（因为初始延迟会重新计算）。 方法二：在任务执行体中控制只执行一次。我们可以在任务执行时记录状态（比如在数据库中记录或使用一个原子变量），确保即使任务被多次触发，实际业务逻辑也只执行一次。 然而，用户要求的是“单次执行”，即任务在应用启动后只执行一次，且不重复执行。我们可以结合Spring Boot的任务调度机制，通过编程方式动态注册任务，并在任务执行后取消调度。 具体步骤： 1. 创建一个实现`Runnable`接口的任务类。 2. 使用`ScheduledTaskRegistrar`动态注册一个只执行一次的任务（通过`ScheduledFuture`）。 3. 在任务执行完毕后，取消该任务的调度。 这种方法的优点： - 任务只会在注册后执行一次 - 不会因为应用长时间运行而导致重复执行 - 不需要依赖外部存储状态 实现代码： 步骤1：创建任务类（可以是Runnable的匿名内部类） 步骤2：使用`ScheduledTaskRegistrar`的`scheduler`调度一次任务 步骤3：在任务中执行逻辑，然后取消任务 注意：我们需要获取到`ScheduledFuture`对象，以便在任务执行后取消。 但是，在Spring Boot中，我们通常通过配置`SchedulingConfigurer`来使用`ScheduledTaskRegistrar`。 下面是一个完整的实现示例： ```java import org.springframework.context.annotation.Configuration; import org.springframework.scheduling.annotation.EnableScheduling; import org.springframework.scheduling.annotation.SchedulingConfigurer; import org.springframework.scheduling.config.ScheduledTaskRegistrar; import java.util.concurrent.ScheduledFuture; import java.util.concurrent.TimeUnit; @Configuration @EnableScheduling public class OneTimeScheduledTask implements SchedulingConfigurer { @Override public void configureTasks(ScheduledTaskRegistrar taskRegistrar) { // 创建一个任务 Runnable task = () -> { try { // 这里写你的业务逻辑，只执行一次 System.out.println("执行一次定时任务"); } finally { // 任务执行完成后，取消调度（避免重复执行） // 注意：这里需要访问到ScheduledFuture，所以我们在定义任务时将其捕获 } }; // 使用ScheduledFuture来跟踪任务，以便取消 ScheduledFuture<?> future = taskRegistrar.getScheduler().schedule( task, triggerContext -> { // 设置任务在应用启动后立即执行（延迟0秒） return new Date(System.currentTimeMillis()); } ); // 修改任务，使其在执行完成后取消 Runnable wrappedTask = () -> { task.run(); // 取消任务 future.cancel(false); }; // 重新调度任务（实际执行的是包装后的任务） taskRegistrar.addTriggerTask(wrappedTask, triggerContext -> { // 立即执行一次 return new Date(System.currentTimeMillis()); }); } } ``` 然而，上述代码有一个问题：`ScheduledFuture`是在任务被调度执行之前就获取的，并且我们包装了一个新的任务，在原始任务执行后取消。但是，注意我们使用`addTriggerTask`重新添加了一个任务，而之前用`schedule`方法调度的任务实际上没有被取消，所以我们需要避免两个任务同时存在。 优化方案：我们只使用一次触发任务，并在任务执行后取消自己。但是，在触发任务中我们无法直接获取到自己的`ScheduledFuture`。 因此，我们可以这样做： ```java @Configuration @EnableScheduling public class OneTimeScheduledTask implements SchedulingConfigurer { @Override public void configureTasks(ScheduledTaskRegistrar taskRegistrar) { // 使用一个原子引用保存ScheduledFuture AtomicReference<ScheduledFuture<?>> futureRef = new AtomicReference<>(); Runnable task = () -> { try { // 业务逻辑 System.out.println("执行一次定时任务"); } finally { // 取消任务 ScheduledFuture<?> future = futureRef.get(); if (future != null) { future.cancel(false); } } }; // 定义一个Trigger，用于确定任务执行时间（立即执行） Trigger trigger = triggerContext -> new Date(); // 添加任务，并捕获返回的ScheduledFuture ScheduledFuture<?> future = taskRegistrar.getScheduler().schedule(task, trigger); futureRef.set(future); } } ``` 但是，这样写有一个问题：`ScheduledTaskRegistrar`的`getScheduler()`返回的是`ScheduledExecutorService`，它的`schedule`方法只执行一次。所以，我们不需要在任务中取消，因为`schedule`方法本来就是只执行一次的。 因此，最简单的方案是： ```java @Configuration @EnableScheduling public class OneTimeScheduledTask implements SchedulingConfigurer { @Override public void configureTasks(ScheduledTaskRegistrar taskRegistrar) { taskRegistrar.getScheduler().schedule( () -> { // 这里写只执行一次的任务逻辑 System.out.println("执行一次定时任务"); }, 0, // 延迟0秒，立即执行 TimeUnit.SECONDS ); } } ``` 这样，任务只会在应用启动后执行一次，因为`schedule`方法就是用于安排一个在给定延迟后只执行一次的任务。 所以，我们不需要额外的取消操作。 验证：当应用启动时，任务会执行一次，然后不会再次执行。 但是，请注意：`ScheduledTaskRegistrar`的`getScheduler()`方法返回的`ScheduledExecutorService`是由Spring管理的，它会在应用关闭时自动关闭。 因此，推荐使用这种简单的方式。 另外，我们也可以使用`@Scheduled`注解的方式，但需要结合条件控制，比如使用一个标志位： ```java @Component @EnableScheduling public class OneTimeTask { private AtomicBoolean executed = new AtomicBoolean(false); @Scheduled(fixedDelay = Long.MAX_VALUE) // 设置一个非常大的延迟，确保不会重复执行 public void executeOnce() { if (executed.compareAndSet(false, true)) { // 执行任务 System.out.println("执行一次"); } } } ``` 但是，这种方法实际上任务被多次触发（虽然业务逻辑只执行一次），而且第一次触发后，由于设置了`Long.MAX_VALUE`的延迟，几乎不会再次触发（除非应用运行超过290年）。所以，这种方法虽然可行，但不够直观。 结论：使用`SchedulingConfigurer`和`ScheduledExecutorService.schedule()`方法是最直接且符合需求的。 因此，我们给出最终方案： ```java import org.springframework.context.annotation.Configuration; import org.springframework.scheduling.annotation.EnableScheduling; import org.springframework.scheduling.annotation.SchedulingConfigurer; import org.springframework.scheduling.config.ScheduledTaskRegistrar; import java.util.concurrent.TimeUnit; @Configuration @EnableScheduling public class OneTimeTaskConfig implements SchedulingConfigurer { @Override public void configureTasks(ScheduledTaskRegistrar taskRegistrar) { // 在应用启动后，延迟0秒执行一次 taskRegistrar.getScheduler().schedule(() -> { // 这里写你的业务代码 System.out.println("This task runs only once after application starts."); }, 0, TimeUnit.SECONDS); } } ``` 这样，任务将在Spring Boot应用启动后立即执行一次，且只执行一次。 注意事项： 1. 确保任务执行时间不要太长，以免阻塞其他任务（如果任务耗时较长，建议使用异步任务）。 2. 如果任务执行过程中抛出异常，需要根据业务需求处理异常，避免影响应用运行。 引用说明： 在Spring Boot中，通过`SchedulingConfigurer`可以自定义任务调度器，并动态添加任务[^2]。使用`ScheduledExecutorService`的`schedule`方法可以安排一次性任务[^4]。 因此，我们推荐使用上述配置类的方式实现单次执行定时任务。 相关问题： 1. 如何在Spring Boot中实现只执行一次的定时任务？ 2. Spring Boot定时任务单次执行有哪些方法？ 3. 如何动态注册Spring Boot定时任务？ 4. 在Spring Boot中如何取消已经注册的定时任务？</think>在 Spring Boot 中实现定时任务单次执行，可以通过以下两种推荐方法实现： ### 方法一：使用 `@Scheduled` 结合执行标志位（推荐） ```java import org.springframework.scheduling.annotation.Scheduled; import org.springframework.stereotype.Component; import java.util.concurrent.atomic.AtomicBoolean; @Component public class OneTimeScheduledTask { private final AtomicBoolean executed = new AtomicBoolean(false); // 应用启动后立即执行一次 @Scheduled(initialDelay = 0) public void executeOnce() { if (executed.compareAndSet(false, true)) { // 这里放置需要执行一次的代码 System.out.println("任务执行一次完成"); // 实际业务逻辑示例： // dataMigrationService.migrateDataOnce(); } } } ``` **实现原理：** 1. 使用 `AtomicBoolean` 确保线程安全的执行状态控制 2. `@Scheduled(initialDelay = 0)` 使任务在应用启动后立即执行 3. `compareAndSet(false, true)` 保证只执行一次 4. 符合 Spring Boot 定时任务规范，无需额外配置[^1][^2] ### 方法二：使用 `ScheduledExecutorService` 实现精确控制 ```java import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import javax.annotation.PostConstruct; import java.util.concurrent.Executors; import java.util.concurrent.ScheduledExecutorService; import java.util.concurrent.TimeUnit; @Configuration public class OneTimeTaskConfig { @PostConstruct public void scheduleOneTimeTask() { ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor(); // 延迟0秒执行（立即执行） executor.schedule(() -> { // 这里放置需要执行一次的代码 System.out.println("一次性任务执行完成"); // 实际业务逻辑示例： // dataMigrationService.migrateDataOnce(); executor.shutdown(); // 关闭线程池 }, 0, TimeUnit.SECONDS); } } ``` **两种方法对比：** | 特性 | `@Scheduled` + 标志位 | `ScheduledExecutorService` | |------|----------------------|----------------------------| | 复杂度 | 简单 | 中等 | | 线程管理 | Spring 管理 | 手动管理 | | 启动时机 | 随 Spring 容器启动 | 精确控制 | | 适合场景 | 常规单次任务 | 需要精细控制的任务 | | 是否依赖 Spring | 是 | 否 | ### 注意事项 1. **分布式环境**：在集群部署时，需使用分布式锁（如 Redis 锁）替代 `AtomicBoolean`，避免多实例重复执行 2. **执行时间**：确保任务执行时间合理，避免阻塞应用启动 3. **异常处理**：添加 try-catch 块捕获异常，防止单次任务失败导致业务中断 4. **任务可见性**：建议添加日志记录，明确标记任务执行状态 ### 配置说明 在启动类添加 `@EnableScheduling` 注解（仅方法一需要）： ```java @SpringBootApplication @EnableScheduling // 启用定时任务 public class Application { public static void main(String[] args) { SpringApplication.run(Application.class, args); } } ``` > **提示**：对于需要精确控制执行时间的单次任务（如特定日期执行），可结合 `@Scheduled(cron = "一次性时间表达式")` 实现[^4]。对于需要任务执行后立即销毁的场景，推荐使用方法二。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值