投稿
  1. 极客之音首页
  2. 后端开发
  3. Java

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

小半 • • Java • 阅读 144

导读：本篇文章讲解 springboot进阶学习（二）springboot定时任务，希望对大家有帮助，欢迎收藏，转发！站点地址：www.bmabk.com

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如何来实现定时任务。定时任务执行方式有两种：

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

单线程示例

  1. 我们先创建一个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=”…”) 表达式来设置定时任务，也就是设置我们任务执行的策略，具体设置方法参考下一节定时任务配置详解
  1. 然后在启动类上面加上@EnableScheduling注解， 作用是发现组件里面带@Scheduled注解的任务并在后台执行该任务。
@SpringBootApplication
@EnableScheduling //开启定时任务
public class Springboot2Test02Application extends SpringBootServletInitializer {
    public static void main(String[] args) throws UnknownHostException {
        SpringApplication.run(Springboot2Test02Application.class, args);
    }
}
  1. 启动项目，看到控制台会有如下信息，表明控制台里面已经定时执行我们的任务了
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
  1. 上述方法可以实现定时任务，方式也比较简单，不用配置什么文件啥的，但你会发现一个问题，两个任务的id和name都是相同的，也就是说我们只有一个线程来执行
    任务。大家可以试下，即使多创建几个类，在类里面的方法上加上@Scheduled开启任务，最后执行的时候都是一个线程来完成的。springboot默认就是单线程。

多线程示例

  1. 创建一个任务配置类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;
    }
}
  1. 创建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注解，表示这个一个异步的任务

  1. 在启动类上加@EnableAsync表示开启多线程，也就是异步任务
@SpringBootApplication
@EnableScheduling //开启定时任务
@EnableAsync //开启多线程
public class Springboot2Test02Application extends SpringBootServletInitializer {
    public static void main(String[] args) throws UnknownHostException {
        SpringApplication.run(Springboot2Test02Application.class, args);
    }
}
  1. 启动项目，可以在控制台看到如下信息，表明任务有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

配置多个线程池

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

  1. 我们再创建一个任务配置类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，后面会用到

  1. 再创建一个测试类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，加入那个该任务就在哪个线程池里面。

  1. 启动任务后，在控制台可以看到，两个任务分别在各自的线程池内执行。
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乐园 🍉🍉🍉

版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。

文章由极客之音整理，本文链接：https://www.bmabk.com/index.php/post/13514.html

赞 (0)
小半的头像小半
0 0

相关推荐

极客之音——专业性很强的中文编程技术网站，欢迎收藏到浏览器，订阅我们！