SpringBoot 创建定时任务、异步调用

最新推荐文章于 2023-10-08 16:54:39 发布

一名技术极客

最新推荐文章于 2023-10-08 16:54:39 发布

阅读量713

点赞数

分类专栏： spring boot 文章标签： spring boot java 定时任务

本文链接：https://blog.csdn.net/weixin_42081445/article/details/120288312

版权

spring boot 专栏收录该内容

15 篇文章 2 订阅

订阅专栏

SpringBoot 创建定时任务、异步调用

SpringBoot 使用定时任务@Scheduled-fixedRate方式
- 创建定时任务
- `@Scheduled`参数说明
SpringBoot 使用定时任务@Scheduled-cron方式
SpringBoot 使用@Async实现异步调用
- 同步调用
- 异步调用
Spring Boot 使用@Async 实现异步调用-异步回调结果
Spring Boot 使用@Async 实现异步调用-自定义线程池
通过数据库简单的配置定时任务

SpringBoot 使用定时任务@Scheduled-fixedRate方式

在项目开发中，经常需要定时任务来帮助我们来做一些内容，比如定时发送短息/站内信、数据汇总统计、业务监控等。

创建定时任务

在spring boot 中填写定时任务是非常简单的事，下面通过实例介绍如何在spring boot 中创建定时任务

pom 配置（只需要引入spring-boot-starter jar包即可，spring-boot-starter 中已经内置了定时的方法）

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

在spring boot主类中加入@EnableScheduling注解，启用定时任务配置

package com.djy.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableScheduling;

@SpringBootApplication
@EnableScheduling
public class SpringDemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(SpringDemoApplication.class, args);
    }

}

创建定时任务实现类

@Component
public class SchedulingTask {
    private static final SimpleDateFormat f = new SimpleDateFormat("HH:mm:ss");

    //五秒执行一次
    @Scheduled(fixedRate = 5000)
    public void processFixedRate() {
        System.out.println("Scheduled-fixedRate 方式：开始定时任务，现在时间："+f.format(new Date()));
    }
}

运行程序，控制台中可以看到类似的输出，定时任务开始正常运作了。
在这里插入图片描述

`@Scheduled`参数说明

在上面的例子中，使用了@Scheduled(fixedRate = 5000)注解来定义每5秒执行的任务，对于@Scheduled的使用可以总结如下几种方式：

fixedRate 说明

@Scheduled(fixedRate = 5000) 上一次开始执行时间点之后5秒在执行
@Scheduled(fixedDelay = 5000) 上一次执行完毕时间点之后5秒执行
@Scheduled(initialDelay = 1000 ,fixedRate = 5000) 第一次延迟1秒后执行，之后按fixedRate的规则每5秒执行一次

SpringBoot 使用定时任务@Scheduled-cron方式

修改 SchedulingTask（定时任务实现类）

@Component
public class SchedulingTask {
    private static final SimpleDateFormat f = new SimpleDateFormat("HH:mm:ss");


//    @Scheduled(fixedRate = 5000)
//    public void processFixedRate() {
//        System.out.println("Scheduled-fixedRate 方式：开始定时任务，现在时间："+f.format(new Date()));
//    }

    @Scheduled(cron = "*/5 * * * * ?")
    public void processCron() {
        System.out.println("Scheduled-cron 方式：开始定时任务，现在时间："+f.format(new Date()));
    }
}

运行程序，控制台中可以看到类似的输出，定时任务开始正常运作了。
在这里插入图片描述

参数说明

每一个域都使用数字，但还可以出现如下特殊字符，它们的含义是：

（1）：表示匹配该域的任意值。假如在Minutes域使用, 即表示每分钟都会触发事件。

（2）?：只能用在DayofMonth和DayofWeek两个域。它也匹配域的任意值，但实际不会。因为DayofMonth和DayofWeek会相互影响。例如想在每月的20日触发调度，不管20日到底是星期几，则只能使用如下写法： 13 13 15 20 * ?, 其中最后一位只能用？，而不能使用*，如果使用*表示不管星期几都会触发，实际上并不是这样。

（3）-：表示范围。例如在Minutes域使用5-20，表示从5分到20分钟每分钟触发一次

（4）/：表示起始时间开始触发，然后每隔固定时间触发一次。例如在Minutes域使用5/20,则意味着5分钟触发一次，而25，45等分别触发一次.

（5）,：表示列出枚举值。例如：在Minutes域使用5,20，则意味着在5和20分每分钟触发一次。

（6）L：表示最后，只能出现在DayofWeek和DayofMonth域。如果在DayofWeek域使用5L,意味着在最后的一个星期四触发。

（7）W:表示有效工作日(周一到周五),只能出现在DayofMonth域，系统将在离指定日期的最近的有效工作日触发事件。例如：在 DayofMonth使用5W，如果5日是星期六，则将在最近的工作日：星期五，即4日触发。如果5日是星期天，则在6日(周一)触发；如果5日在星期一到星期五中的一天，则就在5日触发。另外一点，W的最近寻找不会跨过月份。

（8）LW:这两个字符可以连用，表示在某个月最后一个工作日，即最后一个星期五。

（9）#:用于确定每个月第几个星期几，只能出现在DayofMonth域。例如在4#2，表示某月的第二个星期三。

cron 常用表达式例子

（0）0/20 * * * * ? 表示每20秒调整任务

（1）0 0 2 1 * ? 表示在每月的1日的凌晨2点调整任务

（2）0 15 10 ? * MON-FRI 表示周一到周五每天上午10:15执行作业

（3）0 15 10 ? 6L 2002-2006 表示2002-2006年的每个月的最后一个星期五上午10:15执行作

（4）0 0 10,14,16 * * ? 每天上午10点，下午2点，4点

（5）0 0/30 9-17 * * ? 朝九晚五工作时间内每半小时

（6）0 0 12 ? * WED 表示每个星期三中午12点

（7）0 0 12 * * ? 每天中午12点触发

（8）0 15 10 ? * * 每天上午10:15触发

（9）0 15 10 * * ? 每天上午10:15触发

（10）0 15 10 * * ? * 每天上午10:15触发

（11）0 15 10 * * ? 2005 2005年的每天上午10:15触发

（12）0 * 14 * * ? 在每天下午2点到下午2:59期间的每1分钟触发

（13）0 0/5 14 * * ? 在每天下午2点到下午2:55期间的每5分钟触发

（14）0 0/5 14,18 * * ? 在每天下午2点到2:55期间和下午6点到6:55期间的每5分钟触发

（15）0 0-5 14 * * ? 在每天下午2点到下午2:05期间的每1分钟触发

（16）0 10,44 14 ? 3 WED 每年三月的星期三的下午2:10和2:44触发

（17）0 15 10 ? * MON-FRI 周一至周五的上午10:15触发

（18）0 15 10 15 * ? 每月15日上午10:15触发

（19）0 15 10 L * ? 每月最后一日的上午10:15触发

（20）0 15 10 ? * 6L 每月的最后一个星期五上午10:15触发

（21）0 15 10 ? * 6L 2002-2005 2002年至2005年的每月的最后一个星期五上午10:15触发

（22）0 15 10 ? * 6#3 每月的第三个星期五上午10:15触发

SpringBoot 使用@Async实现异步调用

什么是异步调用?
异步调用的应得是同步调用，同步调用指程序按照定义顺序依次执行，每一行程序都必须等待上一行下执行程序执行完成之后才执行，异步调用指程序在顺序执行时，不等待异步调用的语句返回结果里就执行后。

同步调用

下面通过一个简单的示例来直观的理解什么是同步调用:

定义Task类，创建三个处理函数分别模拟三个执行任务的操作，操作消耗时间随机取（10秒内）

@Component
public class MyTask {

    public static Random random = new Random();

    public void doTaskOne() throws Exception {
        System.out.println("开始做任务一");
        long start = System.currentTimeMillis();
        Thread.sleep(random.nextInt(10000));
        long end = System.currentTimeMillis();
        System.out.println("完成任务一，耗时：" + (end - start) + "毫秒");
    }

    public void doTaskTwo() throws Exception {
        System.out.println("开始做任务二");
        long start = System.currentTimeMillis();
        Thread.sleep(random.nextInt(10000));
        long end = System.currentTimeMillis();
        System.out.println("完成任务二，耗时：" + (end - start) + "毫秒");
    }

    public void doTaskThree() throws Exception {
        System.out.println("开始做任务三");
        long start = System.currentTimeMillis();
        Thread.sleep(random.nextInt(10000));
        long end = System.currentTimeMillis();
        System.out.println("完成任务三，耗时：" + (end - start) + "毫秒");
    }
}

在单元测试用例中，注入Task对象，并在测试用例中执行 doTaskOne 、 doTaskTwo 、 doTaskThree 三个函数。

@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringbootAsyncApplicationTests {
    @Test
    public void contextLoads() {
   }
    @Autowired
    private MyTask myTask;
    @Test
    public void testTask() throws Exception{
        myTask.doTaskOne();
        myTask.doTaskTwo();
        myTask.doTaskThree();
   }
}

执行单元测试，可以看到类似如下输出：

开始做任务一
完成任务一，耗时：8653毫秒
开始做任务二
完成任务二，耗时：5215毫秒
开始做任务三
完成任务三，耗时：648毫秒

任务一、任务二、任务三顺序的执行完了，换言之 doTaskOne 、 doTaskTwo 、 doTaskThree 三个函数顺序的执行完成。

异步调用

上述的同步调用虽然顺利的执行完了三个任务，但是可以看到执行时间比较长，若这三个任务本身之间不存在依赖关系，可以并发执行的话，同步调用在执行效率方面就比较差，可以考虑通过异步调用的方式来并发执行。

在Spring Boot中，我们只需要通过使用 @Async 注解就能简单的将原来的同步函数变为异步函数，Task类改在为如下模式：

@Component
public class MyTask {
    public static Random random =new Random();
    @Async
    public void doTaskOne() throws Exception {
        System.out.println("开始做任务一");
        long start = System.currentTimeMillis();
        Thread.sleep(random.nextInt(10000));
        long end = System.currentTimeMillis();
        System.out.println("完成任务一，耗时：" + (end - start) + "毫秒");
   }
    @Async
    public void doTaskTwo() throws Exception {
        System.out.println("开始做任务二");
        long start = System.currentTimeMillis();
        Thread.sleep(random.nextInt(10000));
        long end = System.currentTimeMillis();
        System.out.println("完成任务二，耗时：" + (end - start) + "毫秒");
   }
    @Async
    public void doTaskThree() throws Exception {
        System.out.println("开始做任务三");
        long start = System.currentTimeMillis();
        Thread.sleep(random.nextInt(10000));
        long end = System.currentTimeMillis();
        System.out.println("完成任务三，耗时：" + (end - start) + "毫秒");
   }
}

为了让@Async注解能够生效，还需要在Spring Boot的主程序中配置@EnableAsync，如下所示：

@SpringBootApplication
@EnableAsync
public class SpringbootAsyncApplication {
    public static void main(String[] args) {
        SpringApplication.run(SpringbootAsyncApplication.class, args);
   }
}

此时可以反复执行单元测试，您可能会遇到各种不同的结果，比如：

没有任何任务相关的输出
有部分任务相关的输出
乱序的任务相关的输出

原因是目前 doTaskOne 、 doTaskTwo 、 doTaskThree 三个函数的时候已经是异步执行了。主程序在异步调用之后，主程序并不会理
会这三个函数是否执行完成了，由于没有其他需要执行的内容，所以程序就自动结束了，导致了不完整或是没有输出任务相关内容的
情况。
注： @Async所修饰的函数不要定义为static类型，这样异步调用不会生效

Spring Boot 使用@Async 实现异步调用-异步回调结果

为了让 doTaskOne 、 doTaskTwo 、 doTaskThree 能正常结束，假设我们需要统计一下三个任务并发执行共耗时多少，这就需要等到
上述三个函数都完成调动之后记录时间，并计算结果。

那么我们如何判断上述三个异步调用是否已经执行完成呢？我们需要使用 Future 来返回异步调用的结果，改造完成后如下：

@Component
public class MyTask {
    public static Random random =new Random();
    @Async
    public Future<String> doTaskOne() throws Exception {
        System.out.println("开始做任务一");
        long start = System.currentTimeMillis();
        Thread.sleep(random.nextInt(10000));
        long end = System.currentTimeMillis();
        System.out.println("完成任务一，耗时：" + (end - start) + "毫秒");
        return new AsyncResult<>("完成任务一");
   }
    @Async
    public Future<String> doTaskTwo() throws Exception {
        System.out.println("开始做任务二");
        long start = System.currentTimeMillis();
        Thread.sleep(random.nextInt(10000));
        long end = System.currentTimeMillis();
        System.out.println("完成任务二，耗时：" + (end - start) + "毫秒");
        return new AsyncResult<>("完成任务二");
   }
    @Async
    public Future<String> doTaskThree() throws Exception {
        System.out.println("开始做任务三");
        long start = System.currentTimeMillis();
        Thread.sleep(random.nextInt(10000));
        long end = System.currentTimeMillis();
        System.out.println("完成任务三，耗时：" + (end - start) + "毫秒");
        return new AsyncResult<>("完成任务三");
   }
}

下面我们改造一下测试用例，让测试在等待完成三个异步调用之后来做一些其他事情。

   @Test
    public void testTask() throws Exception{
//       myTask.doTaskOne();
//       myTask.doTaskTwo();
//       myTask.doTaskThree();
        long start = System.currentTimeMillis();
        Future<String> task1 = myTask.doTaskOne();
        Future<String> task2 = myTask.doTaskTwo();
        Future<String> task3 = myTask.doTaskThree();
        while(true) {
            if(task1.isDone() && task2.isDone() && task3.isDone()) {
                // 三个任务都调用完成，退出循环等待
                break;
           }
            Thread.sleep(1000);
       }
            long end = System.currentTimeMillis();
        System.out.println("任务全部完成，总耗时：" + (end - start) + "毫秒");
   }

看看我们做了哪些改变：

在测试用例一开始记录开始时间
在调用三个异步函数的时候，返回 Future 类型的结果对象
在调用完三个异步函数之后，开启一个循环，根据返回的 Future 对象来判断三个异步函数是否都结束了。若都结
束，就结束循环；若没有都结束，就等1秒后再判断。
跳出循环之后，根据结束时间 - 开始时间，计算出三个任务并发执行的总耗时。

执行一下上述的单元测试，可以看到如下结果

开始做任务二
开始做任务一
开始做任务三
完成任务二，耗时：1904毫秒
完成任务三，耗时：1914毫秒
完成任务一，耗时：4246毫秒
任务全部完成，总耗时：5008毫秒

Spring Boot 使用@Async 实现异步调用-自定义线程池

开启异步注解 @EnableAsync 方法上加 @Async 默认实现 SimpleAsyncTaskExecutor 不是真的线程池，这个类不重用线程，每次调用
都会创建一个新的线程

配置线程池

    @Bean("myTaskExecutor")
    public Executor myTaskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(10);//核心线程数量，线程池创建时候初始化的线程数
        executor.setMaxPoolSize(15);//最大线程数，只有在缓冲队列满了之后才会申请超过核心线程数的线程
        executor.setQueueCapacity(200);//缓冲队列，用来缓冲执行任务的队列
        executor.setKeepAliveSeconds(60);//当超过了核心线程数之外的线程在空闲时间到达之后会被销毁
        executor.setThreadNamePrefix("myTask-");//设置好了之后可以方便我们定位处理任务所在的线程池
        executor.setWaitForTasksToCompleteOnShutdown(true);//用来设置线程池关闭的时候等待所有任务都完成再继续销毁其他的Bean
        executor.setAwaitTerminationSeconds(60);//该方法用来设置线程池中任务的等待时间，如果超过这个时候还没有销毁就强制销毁，以确保应用最后能够被关闭，而不是阻塞住。
        //线程池对拒绝任务的处理策略：这里采用了CallerRunsPolicy策略，当线程池没有处理能力的时候，该策略会直接在execute 方法的调用线程中运行被拒绝的任务；如果执行程序已关闭，则会丢弃该任务
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        return executor;
   }

改造MyTask

@Component
public class MyTask {
    public static Random random =new Random();
    @Async("myTaskExecutor")
    public Future<String> doTaskOne() throws Exception {
        System.out.println("开始做任务一");
        long start = System.currentTimeMillis();
        Thread.sleep(random.nextInt(10000));
        long end = System.currentTimeMillis();
        System.out.println("完成任务一，耗时：" + (end - start) + "毫秒");
        return new AsyncResult<>("完成任务一");
   }
    @Async("myTaskExecutor")
    public Future<String> doTaskTwo() throws Exception {
        System.out.println("开始做任务二");
        long start = System.currentTimeMillis();
        Thread.sleep(random.nextInt(10000));
        long end = System.currentTimeMillis();
        System.out.println("完成任务二，耗时：" + (end - start) + "毫秒");
        return new AsyncResult<>("完成任务二");
   }
    @Async("myTaskExecutor")
    public Future<String> doTaskThree() throws Exception {
        System.out.println("开始做任务三");
        long start = System.currentTimeMillis();
        Thread.sleep(random.nextInt(10000));
        long end = System.currentTimeMillis();
        System.out.println("完成任务三，耗时：" + (end - start) + "毫秒");
        return new AsyncResult<>("完成任务三");
   }
}

执行一下上述的单元测试，可以看到如下结果：

开始做任务二
开始做任务三
开始做任务一
完成任务一，耗时：1090毫秒
完成任务三，耗时：4808毫秒
完成任务二，耗时：5942毫秒
任务全部完成，总耗时：6018毫秒

通过数据库简单的配置定时任务

package com.example.scheduledTask;
 
import com.example.mybatis.dao.SysTaskMapper;
import com.example.mybatis.model.SysTask;
import com.example.mybatis.model.SysTaskExample;
import com.example.util.SpringUtil;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Lazy;
import org.springframework.scheduling.Trigger;
import org.springframework.scheduling.TriggerContext;
import org.springframework.scheduling.annotation.SchedulingConfigurer;
import org.springframework.scheduling.config.ScheduledTaskRegistrar;
import org.springframework.scheduling.support.CronTrigger;
import org.springframework.stereotype.Component;
 
import javax.annotation.Resource;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;
 
@Lazy(value = false)
@Component
public class SysTaskConfig implements SchedulingConfigurer {
 
    protected static Logger logger = LoggerFactory.getLogger(SysTaskConfig.class);
 
    private SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
 
    @Resource
    private SysTaskMapper sysTaskMapper;
 
    //从数据库里取得所有要执行的定时任务
    private List<SysTask> getAllTasks() {
        SysTaskExample example=new SysTaskExample();
        example.createCriteria().andIsDeleteEqualTo((byte) 0);
        return sysTaskMapper.selectByExample(example);
    }
 
    @Override
    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
        List<SysTask> tasks=getAllTasks();
        logger.info("定时任务启动,预计启动任务数量="+tasks.size()+"; time="+sdf.format(new Date()));
 
        //校验数据（这个步骤主要是为了打印日志，可以省略）
        checkDataList(tasks);
 
        //通过校验的数据执行定时任务
        int count = 0;
        if(tasks.size()>0) {
            for (int i = 0; i < tasks.size(); i++) {
                try {
                    taskRegistrar.addTriggerTask(getRunnable(tasks.get(i)), getTrigger(tasks.get(i)));
                    count++;
                } catch (Exception e) {
                    logger.error("定时任务启动错误:" + tasks.get(i).getClassName() + ";" + tasks.get(i).getMethodName() + ";" + e.getMessage());
                }
            }
        }
        logger.info("定时任务实际启动数量="+count+"; time="+sdf.format(new Date()));
    };
 
 
    private Runnable getRunnable(SysTask task){
        return new Runnable() {
            @Override
            public void run() {
                try {
                    Object obj = SpringUtil.getBean(task.getClassName());
                    Method method = obj.getClass().getMethod(task.getMethodName(),null);
                    method.invoke(obj);
                } catch (InvocationTargetException e) {
                    logger.error("定时任务启动错误，反射异常:"+task.getClassName()+";"+task.getMethodName()+";"+ e.getMessage());
                } catch (Exception e) {
                    logger.error(e.getMessage());
                }
            }
        };
    }
 
    private Trigger getTrigger(SysTask task){
        return new Trigger() {
            @Override
            public Date nextExecutionTime(TriggerContext triggerContext) {
                //将Cron 0/1 * * * * ? 输入取得下一次执行的时间
                CronTrigger trigger = new CronTrigger(task.getCron());
                Date nextExec = trigger.nextExecutionTime(triggerContext);
                return nextExec;
            }
        };
 
    }
 
    private List<SysTask> checkDataList(List<SysTask> list) {
        String errMsg="";
        for(int i=0;i<list.size();i++){
            if(!checkOneData(list.get(i)).equalsIgnoreCase("success")){
                errMsg+=list.get(i).getTaskName()+";";
                list.remove(list.get(i));
                i--;
            };
        }
        if(!StringUtils.isBlank(errMsg)){
            errMsg="未启动的任务:"+errMsg;
            logger.error(errMsg);
        }
    return list;
    }
 
    private String checkOneData(SysTask task){
        String result="success";
        Class cal= null;
        try {
            cal = Class.forName(task.getClassName());
 
            Object obj =SpringUtil.getBean(cal);
            Method method = obj.getClass().getMethod(task.getMethodName(),null);
            String cron=task.getCron();
            if(StringUtils.isBlank(cron)){
                result="定时任务启动错误，无cron:"+task.getTaskName();
                logger.error(result);
            }
        } catch (ClassNotFoundException e) {
            result="定时任务启动错误，找不到类:"+task.getClassName()+ e.getMessage();
            logger.error(result);
        } catch (NoSuchMethodException e) {
            result="定时任务启动错误，找不到方法,方法必须是public:"+task.getClassName()+";"+task.getMethodName()+";"+ e.getMessage();
            logger.error(result);
        } catch (Exception e) {
          logger.error(e.getMessage());
         }
        return result;
    }
 
 
}

数据库配置
在这里插入图片描述
执行的方法

一名技术极客

关注

0
点赞
踩
4

收藏

觉得还不错? 一键收藏
打赏
0
评论
SpringBoot 创建定时任务、异步调用

SpringBoot 创建定时任务、异步调用SpringBoot 使用定时任务@Scheduled-fixedRate方式创建定时任务`@Scheduled`参数说明SpringBoot 使用定时任务@Scheduled-cron方式修改 SchedulingTask（定时任务实现类）参数说明常用表达式例子SpringBoot 使用@Async实现异步调用SpringBoot 使用定时任务@Scheduled-fixedRate方式在项目开发中，经常需要定时任务来帮助我们来做一些内容，比如定时发送短息/
复制链接

扫一扫