SpringBoot三种方式实现定时任务

谁借莪１个温暖的怀抱￠ 2023-03-02 07:34 2阅读 0赞

SpringBoot三种方式实现定时任务  
定时任务实现的三种方式：

Timer：这是java自带的java.util.Timer类，这个类允许你调度一个java.util.TimerTask任务。使用这种方式可以让你的程序按照某一个频度执行，但不能在指定时间运行。一般用的较少。

ScheduledExecutorService：也jdk自带的一个类；是基于线程池设计的定时任务类,每个调度任务都会分配到线程池中的一个线程去执行,也就是说,任务是并发执行,互不影响。

Spring Task：Spring3.0以后自带的task，可以将它看成一个轻量级的Quartz，而且使用起来比Quartz简单许多。

# 使用Timer #

这个目前在项目中用的较少，直接贴demo代码。具体的介绍可以查看api

1.  `public class TestTimer {`
2.  `    public static void main(String[] args) {`
3.  `        TimerTask timerTask = new TimerTask() {`
4.  `            @Override`
5.  `            public void run() {`
6.  `                System.out.println("task  run:"+ new Date());`
7.  `            }`
8.  `        };`
9.  `        Timer timer = new Timer();`
10. `        //安排指定的任务在指定的时间开始进行重复的固定延迟执行。这里是每3秒执行一次`
11. `        timer.schedule(timerTask,10,3000);`
12. `    }`
13. `}`

# 使用ScheduledExecutorService #

该方法跟Timer类似，直接看demo：

1.  `public class TestScheduledExecutorService {`
2.  `    public static void main(String[] args) {`
3.  `        ScheduledExecutorService service = Executors.newSingleThreadScheduledExecutor();`
4.  `        // 参数：1、任务体 2、首次执行的延时时间`
5.  `        //      3、任务执行间隔 4、间隔时间单位`
6.  `        service.scheduleAtFixedRate(()->System.out.println("task ScheduledExecutorService "+new Date()), 0, 3, TimeUnit.SECONDS);`
7.  `    }`
8.  `}`

# 使用Spring Task #

1，简单的定时任务  
在SpringBoot项目中，我们可以很优雅的使用注解来实现定时任务，首先创建项目，导入依赖：

1.  `<dependencies>`
2.  `  <dependency>`
3.  `    <groupId>org.springframework.boot</groupId>`
4.  `    <artifactId>spring-boot-starter-web</artifactId>`
5.  `  </dependency>`
6.  `  <dependency>`
7.  `    <groupId>org.springframework.boot</groupId>`
8.  `    <artifactId>spring-boot-starter</artifactId>`
9.  `  </dependency>`
10. `  <dependency>`
11. `    <groupId>org.projectlombok</groupId>`
12. `    <artifactId>lombok</artifactId>`
13. `    <optional>true</optional>`
14. `  </dependency>`
15. `  <dependency>`
16. `    <groupId>org.springframework.boot</groupId>`
17. `    <artifactId>spring-boot-starter-test</artifactId>`
18. `    <scope>test</scope>`
19. `  </dependency>`
20. `</dependencies>`

创建任务类：

1.  `@Slf4j`
2.  `@Component`
3.  `public class ScheduledService {`
4.  `    @Scheduled(cron = "0/5 * * * * *")`
5.  `    public void scheduled(){`
6.  `        log.info("=====>>>>>使用cron  {}",System.currentTimeMillis());`
7.  `    }`
8.  `    @Scheduled(fixedRate = 5000)`
9.  `    public void scheduled1() {`
10. `        log.info("=====>>>>>使用fixedRate{}", System.currentTimeMillis());`
11. `    }`
12. `    @Scheduled(fixedDelay = 5000)`
13. `    public void scheduled2() {`
14. `        log.info("=====>>>>>fixedDelay{}",System.currentTimeMillis());`
15. `    }`
16. `}`

在主类上使用@EnableScheduling注解开启对定时任务的支持，然后启动项目  
可以看到三个定时任务都已经执行，并且使同一个线程中串行执行，如果只有一个定时任务，这样做肯定没问题，当定时任务增多，如果一个任务卡死，会导致其他任务也无法执行。

2，多线程执行  
在传统的Spring项目中，我们可以在xml配置文件添加task的配置，而在SpringBoot项目中一般使用config配置类的方式添加配置，所以新建一个AsyncConfig类

1.  `@Configuration`
2.  `@EnableAsync`
3.  `public class AsyncConfig {`
4.  `     /*`
5.  `    此处成员变量应该使用@Value从配置中读取`
6.  `     */`
7.  `    private int corePoolSize = 10;`
8.  `    private int maxPoolSize = 200;`
9.  `    private int queueCapacity = 10;`
10. `    @Bean`
11. `    public Executor taskExecutor() {`
12. `        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();`
13. `        executor.setCorePoolSize(corePoolSize);`
14. `        executor.setMaxPoolSize(maxPoolSize);`
15. `        executor.setQueueCapacity(queueCapacity);`
16. `        executor.initialize();`
17. `        return executor;`
18. `    }`
19. `}`

@Configuration：表明该类是一个配置类  
@EnableAsync：开启异步事件的支持

然后在定时任务的类或者方法上添加@Async 。最后重启项目，每一个任务都是在不同的线程中。