SpringBoot(十三)：springboot2.0.2定时任务

时间 2019-12-04

标签 springboot 十三 springboot2.0.2 定时任务栏目 Spring 繁體版

原文原文链接

使用定义任务：

第一步：启用定时任务
第二步：配置定时器资源等
第三步：定义定时任务并指定触发规则web

1)启动类启用定时任务

在springboot入口类上添加注解@EnableScheduling便可。spring

@SpringBootApplication(scanBasePackages = {})
@MapperScan("com.dx.jobmonitor.mapper")
@EnableScheduling
public class App {
    private static final Logger logger = LoggerFactory.getLogger(App.class);

    public static void main(String[] args) {
        logger.info("App start...");
        SpringApplication.run(App.class, args);
    }
}

2）配置定时任务资源等：

设置定时任务线程池大小：经过SchedulingConfigurer接口配置并行方式
当定时任务不少的时候，为了提升任务执行效率，能够采用并行方式执行定时任务，任务之间互不影响，只要实现SchedulingConfigurer接口就能够。数据库

/**
 * 配置定时任务<br>
 * 1）当定时任务不少的时候，为了提升任务执行效率，能够采用并行方式执行定时任务，任务之间互不影响，只要实现SchedulingConfigurer接口就能够。<br>
 * 2）这里指定用3个线程来并行处理
 * **/
@Configuration
public class ScheduledConfig implements SchedulingConfigurer {
    @Override
    public void configureTasks(ScheduledTaskRegistrar scheduledTaskRegistrar) {
        scheduledTaskRegistrar.setScheduler(setTaskExecutors());
    }

    @Bean(destroyMethod = "shutdown")
    public Executor setTaskExecutors() {
        return Executors.newScheduledThreadPool(3);
    }
}

在并行执行的时候，建立线程池采用了newScheduledThreadPool这个线程池。
Executors框架中存在几种线程池的建立线程池的采用的队列是延迟队列:express

newCachedThreadPool() ，
newFixedThreadPool()，
newSingleThreadExecutor(),
newScheduledThreadPool()。

newScheduledThreadPool() 线程池的特性是定时任务可以定时或者周期性的执行任务。springboot

public ScheduledThreadPoolExecutor(int corePoolSize) {
    super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS, new DelayedWorkQueue());
}

其中线程池核心线程数是本身设定的，最大线程数是最大值。阻塞队列是自定义的延迟队列：DelayedWorkQueue()app

3）定义定时任务

定时任务1：框架

@Component
public class SchedulerTask {
    private int count=0;

    @Scheduled(cron="*/6 * * * * ?")
    private void process(){
        System.out.println("this is scheduler task runing  "+(count++));
    }
}

定时任务2：ide

从application.yml中读取cron参数函数

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

    @Scheduled("jobs.scheduled.cron")
    public void reportCurrentTime() {
        System.out.println("如今时间：" + dateFormat.format(new Date()));
    }
}

此时application.yml中配置信息以下：测试

jobs:
  scheduled:
    cron: 0/30 * * * * ?

参数说明：
　　@Scheduled接受两种定时的设置：

一种是cornexpression。

一种是Rate/Delay表达式（毫秒值）：

@Scheduled(fixedRate = 6000)：上一次开始执行时间点后每隔6秒执行一次。

@Scheduled(fixedDelay = 6000)：上一次执行完毕时间点以后6秒再执行。

@Scheduled(initialDelay=1000, fixedRate=6000)：第一次延迟1秒后执行，以后按fixedRate的规则每6秒执行一次。

动态修改scheduled的cron参数：

动态修改定时任务cron参数时：

1）不须要重启应用就能够动态的改变Cron表达式的值
2）不能使用@Scheduled(cron = “${jobs.cron}”)实现

@Component
public class SpringDynamicCronTask implements SchedulingConfigurer {
    private static final Logger logger = LoggerFactory.getLogger(SpringDynamicCronTask.class);
    private static String cron = "0/5 * * * * ?";

    @Autowired
    private TaskDynamicCronService taskCronService;
    
    @Override
    public void configureTasks(ScheduledTaskRegistrar scheduledTaskRegistrar) {
        scheduledTaskRegistrar.addTriggerTask(() -> {
            // 任务逻辑
            logger.error("dynamicCronTask is running...");
        }, triggerContext -> {
            // 任务触发，在这里可修改任务的执行周期,由于每次调度都会执行这里
            // 1)这里能够修改成从数据读取cron
            // cron=taskCronService.getCron();
            CronTrigger cronTrigger = new CronTrigger(cron);
            return cronTrigger.nextExecutionTime(triggerContext);
        });
    }

    /**
    * 2) 供应用端调用动态修改cron参数方法
    * @Controller
    * @RequestMapping("/cron")")
    * public class CronController{
    *        @Autowired
    *        private SpringDynamicCronTask cronTask;
    *
    *         @PostMapping("/update")
    *        @ResponseBody
    *        public String update(String cron) {
    *            cronTask.setCron(cron);
    *        }
    * }
    */ 
    public void setCron(String cron) {
         this.cron=cron;
    }
}

动态设置cron参数经常使用方式包含两种：

1）动态查询并设置cron

定义CronTrigger时，从数据库中动态查询cron并设置

    @Autowired
    private TaskDynamicCronService taskCronService;
    
    @Override
    public void configureTasks(ScheduledTaskRegistrar scheduledTaskRegistrar) {
        scheduledTaskRegistrar.addTriggerTask(() -> {
            // 任务逻辑
            logger.error("dynamicCronTask is running...");
        }, triggerContext -> {
            cron=taskCronService.getCron();
            CronTrigger cronTrigger = new CronTrigger(cron);
            return cronTrigger.nextExecutionTime(triggerContext);
        });
    }

2）经过接口函数修改cron值

SpringDynamicCronTask 类，提供修改cron函数setCron()。

@Component
public class SpringDynamicCronTask implements SchedulingConfigurer {
    private static final Logger logger = LoggerFactory.getLogger(SpringDynamicCronTask.class);
    private static String cron = "0/5 * * * * ?";
    @Override
    public void configureTasks(ScheduledTaskRegistrar scheduledTaskRegistrar) {
        scheduledTaskRegistrar.addTriggerTask(() -> {
            // 任务逻辑
            logger.error("dynamicCronTask is running...");
        }, triggerContext -> {
            CronTrigger cronTrigger = new CronTrigger(cron);
            return cronTrigger.nextExecutionTime(triggerContext);
        });
    }

    /**
    * 供应用端调用动态修改cron参数方法
    */ 
    public void setCron(String cron) {
         this.cron=cron;
    }
}

应用端调用：

@Controller
@RequestMapping("/cron")")
public class CronController{
        @Autowired
        private SpringDynamicCronTask cronTask;

        @PostMapping("/update")
        @ResponseBody
        public String update(String cron) {
           cronTask.setCron(cron);
        }
}

多定时任务管理

定义多定时任务管理类

class BatchTaskSchedule {
    private ThreadPoolTaskScheduler executor = new ThreadPoolTaskScheduler();
    private ScheduledFuture<?> future;
    private Integer key;

    public BatchTaskSchedule(Integer key) {
        this.key = key;
    }

    public void start() {
        executor.setPoolSize(1);
        executor.setThreadNamePrefix("taskExecutor-");
        executor.setWaitForTasksToCompleteOnShutdown(true);
        executor.setAwaitTerminationSeconds(60);
        // 必须得先初始化，才能使用
        executor.initialize();
        future = executor.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("[" + Thread.currentThread().getName() + "-" + key + "]Hello "
                        + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
            }
        }, new CronTrigger("0/15 * * * * ?"));
    }

    public void restart() {
        // 先中止，在开启.
        stop();
        start();
    }

    public void stop() {
        if (future != null) {
            future.cancel(true);
        }
    }
}

使用测试示例:

@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = { App.class }, webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class CommonTest {
    // 定时任务存储集合：当须要中止、重启任务时，能够从该集合中获取待操做任务。
    private static Map<Integer, BatchTaskSchedule> taskBack = new HashMap<Integer, BatchTaskSchedule>();

    @Test
    public void test() {
        for (int i = 0; i < 2; i++) {
            // 建立定时任务
            BatchTaskSchedule taskScheduled = new BatchTaskSchedule(i);
            taskScheduled.start();
            taskBack.put(i, taskScheduled);
        }

        try {
            Thread.sleep(1 * 60 * 1000);
            // 中止掉某个任务
            taskBack.get(0).stop();
            Thread.sleep(1 * 60 * 1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}