springboot进阶学习（二）springboot定时任务

最新推荐文章于 2023-02-16 17:54:16 发布

牛魔王sq

最新推荐文章于 2023-02-16 17:54:16 发布

阅读量216

点赞数

分类专栏： springboot进阶学习文章标签： spring boot java spring

本文链接：https://blog.csdn.net/loveshanqian/article/details/107187025

版权

springboot进阶学习专栏收录该内容

18 篇文章 0 订阅

订阅专栏

springboot定时任务

1介绍
 2springboot定时任务
 3springboot定时任务配置详解
 4springboot动态定时任务
 5springboot集成websocket
6springboot多数据源
 7springboot配置druid监听
 8springboot自定义注解
 9springboot常见注解详解
 10springboot接收参数详解
 11springboot验证机制@Valid和@Validated
12springboot集成Swagger2
13springboot集成swagger-bootstrap-ui
14springboot集成shiro
15springboot集成shiro（二）
16springboot集成jwt
17springboot集成ActiveMQ
18springboot缓存机制

springboot定时任务可以直接使用SpringBoot自带的Scheduled来实现，简单方便快捷。当然也可以使用其它方式。本文主要讲解
SpringBoot自带的Scheduled如何来实现定时任务。定时任务执行方式有两种：

单线程（无论多少个定时任务都只由一个线程来完成，默认是单线程），有的也叫同步任务
多线程（使用的时候需要配置，可以自定义线程数量），有的也叫异步任务

单线程示例

我们先创建一个springboot工程，然后创建一个task的包，在包下创建ScheduleTaskTest类，类里面内容如下：

@Component
@Slf4j
public class ScheduleTaskTest {
    // 每隔5秒钟执行一次任务
    @Scheduled(cron="0/5 * * * * ?")
    private void task1(){
        Thread current = Thread.currentThread();
        log.info("定时任务1:  taskId="+current.getId()+ ",name="+current.getName());
    }
    // 每隔3秒钟执行一次任务
    @Scheduled(cron="0/3 * * * * ?")
    private void task2(){
        Thread current = Thread.currentThread();
        log.info("定时任务2:  taskId="+current.getId()+ ",name="+current.getName());
    }
}

@Scheduled 注解用于标注这个方法是一个定时任务的方法
@Scheduled(cron=”…”) 表达式来设置定时任务，也就是设置我们任务执行的策略，具体设置方法参考下一节定时任务配置详解

然后在启动类上面加上@EnableScheduling注解，作用是发现组件里面带@Scheduled注解的任务并在后台执行该任务。

@SpringBootApplication
@EnableScheduling //开启定时任务
public class Springboot2Test02Application extends SpringBootServletInitializer {
    public static void main(String[] args) throws UnknownHostException {
        SpringApplication.run(Springboot2Test02Application.class, args);
    }
}

启动项目，看到控制台会有如下信息，表明控制台里面已经定时执行我们的任务了

2020-06-06 15:32:03.001  INFO 22772 --- [   scheduling-1] com.moyundong.task.ScheduleTaskTest      : 定时任务2:  taskId=23,name=scheduling-1
2020-06-06 15:32:05.002  INFO 22772 --- [   scheduling-1] com.moyundong.task.ScheduleTaskTest      : 定时任务1:  taskId=23,name=scheduling-1
2020-06-06 15:32:06.001  INFO 22772 --- [   scheduling-1] com.moyundong.task.ScheduleTaskTest      : 定时任务2:  taskId=23,name=scheduling-1
2020-06-06 15:32:09.003  INFO 22772 --- [   scheduling-1] com.moyundong.task.ScheduleTaskTest      : 定时任务2:  taskId=23,name=scheduling-1
2020-06-06 15:32:10.000  INFO 22772 --- [   scheduling-1] com.moyundong.task.ScheduleTaskTest      : 定时任务1:  taskId=23,name=scheduling-1
2020-06-06 15:32:12.001  INFO 22772 --- [   scheduling-1] com.moyundong.task.ScheduleTaskTest      : 定时任务2:  taskId=23,name=scheduling-1

上述方法可以实现定时任务，方式也比较简单，不用配置什么文件啥的，但你会发现一个问题，两个任务的id和name都是相同的，也就是说我们只有一个线程来执行
任务。大家可以试下，即使多创建几个类，在类里面的方法上加上@Scheduled开启任务，最后执行的时候都是一个线程来完成的。springboot默认就是单线程。

多线程示例

创建一个任务配置类TaskConfig，内容如下：

@Configuration
public class TaskConfig {
    //核心线程数，默认是1，为1的时候就是单线程
    private int corePoolSize = 5;
    //最大线程数，核心线程不够用的时候会创建新的线程
    private int maxPoolSize = 20;
    //队列最大长度（容量）
    private int queueCapacity = 5;

    @Bean
    public Executor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(corePoolSize);
        executor.setMaxPoolSize(maxPoolSize);
        executor.setQueueCapacity(queueCapacity);
        executor.initialize();
        return executor;
    }
}

创建AsyncTaskTest用来测试多线程任务

@Component
@Slf4j
//************************多线程示例
public class AsyncTaskTest {
    // 每隔5秒钟执行一次任务
    @Async
    @Scheduled(cron="0/5 * * * * ?")
    public void task3(){
        Thread current = Thread.currentThread();
        log.info("定时任务3:  taskId="+current.getId()+ ",name="+current.getName());
    }
    // 每隔3秒钟执行一次任务
    @Async
    @Scheduled(cron="0/3 * * * * ?")
    public void task4(){
        Thread current = Thread.currentThread();
        log.info("定时任务4:  taskId="+current.getId()+ ",name="+current.getName());
    }
}

多线程的方法上面都加了@Async注解，表示这个一个异步的任务

在启动类上加@EnableAsync表示开启多线程，也就是异步任务

@SpringBootApplication
@EnableScheduling //开启定时任务
@EnableAsync //开启多线程
public class Springboot2Test02Application extends SpringBootServletInitializer {
    public static void main(String[] args) throws UnknownHostException {
        SpringApplication.run(Springboot2Test02Application.class, args);
    }
}

启动项目，可以在控制台看到如下信息，表明任务有5个线程在执行，也就是我们在TaskConfig里面配置的corePoolSize = 5

2020-06-06 16:30:54.024  INFO 38508 --- [ taskExecutor-1] com.moyundong.task.AsyncTaskTest         : 定时任务4:  taskId=48,name=taskExecutor-1
2020-06-06 16:30:55.001  INFO 38508 --- [ taskExecutor-2] com.moyundong.task.AsyncTaskTest         : 定时任务3:  taskId=49,name=taskExecutor-2
2020-06-06 16:30:57.002  INFO 38508 --- [ taskExecutor-3] com.moyundong.task.AsyncTaskTest         : 定时任务4:  taskId=50,name=taskExecutor-3
2020-06-06 16:31:00.001  INFO 38508 --- [ taskExecutor-4] com.moyundong.task.AsyncTaskTest         : 定时任务4:  taskId=51,name=taskExecutor-4
2020-06-06 16:31:00.003  INFO 38508 --- [ taskExecutor-5] com.moyundong.task.AsyncTaskTest         : 定时任务3:  taskId=52,name=taskExecutor-5
2020-06-06 16:31:03.001  INFO 38508 --- [ taskExecutor-1] com.moyundong.task.AsyncTaskTest         : 定时任务4:  taskId=48,name=taskExecutor-1
2020-06-06 16:31:05.001  INFO 38508 --- [ taskExecutor-2] com.moyundong.task.AsyncTaskTest         : 定时任务3:  taskId=49,name=taskExecutor-2
2020-06-06 16:31:06.001  INFO 38508 --- [ taskExecutor-3] com.moyundong.task.AsyncTaskTest         : 定时任务4:  taskId=50,name=taskExecutor-3
2020-06-06 16:31:09.002  INFO 38508 --- [ taskExecutor-4] com.moyundong.task.AsyncTaskTest         : 定时任务4:  taskId=51,name=taskExecutor-4
2020-06-06 16:31:10.002  INFO 38508 --- [ taskExecutor-5] com.moyundong.task.AsyncTaskTest         : 定时任务3:  taskId=52,name=taskExecutor-5

配置多个线程池

因为有些定时任务是比较重要，有些则是不太重要，我们可以把定时任务分别放到不同的线程池中。

我们再创建一个任务配置类TaskConfig2，内容如下：

@Configuration
public class TaskConfig2 {
    //核心线程数，默认是1，为1的时候就是单线程
    private int corePoolSize = 5;
    //最大线程数，核心线程不够用的时候会创建新的线程
    private int maxPoolSize = 20;
    //队列最大长度（容量）
    private int queueCapacity = 5;

    @Bean
    public Executor taskExecutor1() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(corePoolSize);
        executor.setMaxPoolSize(maxPoolSize);
        executor.setQueueCapacity(queueCapacity);
        executor.initialize();
        return executor;
    }

    @Bean
    public Executor taskExecutor2() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(corePoolSize);
        executor.setMaxPoolSize(maxPoolSize);
        executor.setQueueCapacity(queueCapacity);
        executor.initialize();
        return executor;
    }
}

两个Executor的名字分别为taskExecutor1和taskExecutor2，后面会用到

再创建一个测试类AsyncTaskTest2用来测试不同任务使用不同线程池

@Component
@Slf4j
//************************多线程，不同线程不同线程池示例
public class AsyncTaskTest2 {
    // 每隔5秒钟执行一次任务
    @Async("taskExecutor1")
    @Scheduled(cron="0/5 * * * * ?")
    public void task5(){
        Thread current = Thread.currentThread();
        log.info("定时任务5:  taskId="+current.getId()+ ",name="+current.getName());
    }
    // 每隔3秒钟执行一次任务
    @Async("taskExecutor2")
    @Scheduled(cron="0/3 * * * * ?")
    public void task6(){
        Thread current = Thread.currentThread();
        log.info("定时任务6:  taskId="+current.getId()+ ",name="+current.getName());
    }
}

在任务的@Async注解里面加了线程池的名字，也就是taskExecutor1和taskExecutor2，加入那个该任务就在哪个线程池里面。

启动任务后，在控制台可以看到，两个任务分别在各自的线程池内执行。

2020-06-06 16:40:30.012  INFO 43232 --- [taskExecutor1-1] com.moyundong.task.AsyncTaskTest2        : 定时任务5:  taskId=48,name=taskExecutor1-1
2020-06-06 16:40:30.012  INFO 43232 --- [taskExecutor2-1] com.moyundong.task.AsyncTaskTest2        : 定时任务6:  taskId=47,name=taskExecutor2-1
2020-06-06 16:40:33.003  INFO 43232 --- [taskExecutor2-2] com.moyundong.task.AsyncTaskTest2        : 定时任务6:  taskId=49,name=taskExecutor2-2
2020-06-06 16:40:35.001  INFO 43232 --- [taskExecutor1-2] com.moyundong.task.AsyncTaskTest2        : 定时任务5:  taskId=50,name=taskExecutor1-2
2020-06-06 16:40:36.003  INFO 43232 --- [taskExecutor2-3] com.moyundong.task.AsyncTaskTest2        : 定时任务6:  taskId=51,name=taskExecutor2-3
2020-06-06 16:40:39.001  INFO 43232 --- [taskExecutor2-4] com.moyundong.task.AsyncTaskTest2        : 定时任务6:  taskId=52,name=taskExecutor2-4
2020-06-06 16:40:40.002  INFO 43232 --- [taskExecutor1-3] com.moyundong.task.AsyncTaskTest2        : 定时任务5:  taskId=53,name=taskExecutor1-3
2020-06-06 16:40:42.001  INFO 43232 --- [taskExecutor2-5] com.moyundong.task.AsyncTaskTest2        : 定时任务6:  taskId=54,name=taskExecutor2-5
2020-06-06 16:40:45.001  INFO 43232 --- [taskExecutor2-1] com.moyundong.task.AsyncTaskTest2        : 定时任务6:  taskId=47,name=taskExecutor2-1
2020-06-06 16:40:45.003  INFO 43232 --- [taskExecutor1-4] com.moyundong.task.AsyncTaskTest2        : 定时任务5:  taskId=55,name=taskExecutor1-4

::: tip 提示
下载完本节项目代码后：

测试单线程的时候最好把所有多线程的内容注释掉，
测试多线程的时候，可以把TaskConfig2和AsyncTaskTest2相关注解注释掉
测试多线程池的时候，可以把TaskConfig和AsyncTaskTest相关注解注释掉
最好是自己一步一步写一遍代码看看
定时任务配置和线程池配置会在下节讲
:::

本节示例下载地址：java相关demo下载列表

🍉🍉🍉 欢迎大家来博客了解更多内容：java乐园 🍉🍉🍉

牛魔王sq

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
springboot进阶学习（二）springboot定时任务

springboot定时任务springboot定时任务可以直接使用SpringBoot自带的Scheduled来实现，简单方便快捷。当然也可以使用其它方式。本文主要讲解SpringBoot自带的Scheduled如何来实现定时任务。定时任务执行方式有两种：单线程（无论多少个定时任务都只由一个线程来完成，默认是单线程），有的也叫同步任务多线程（使用的时候需要配置，可以自定义线程数量），有的也叫异步任务单线程示例我们先创建一个springboot工程，然后创建一个task的包，在包下创建Sc
复制链接

扫一扫

专栏目录