springboot使用TaskScheduler实现动态增删启停定时任务方式_开发_开发者

TaskScheduler

概述

TaskScheduler是spring 3.0版本后，自带了一个定时任务工具，不用配置文件，可以动态改变执行状态。也可以使用cron表达式设置定时任务。

被执行的类要实现Runnable接口

TaskScheduler是一个接口，它定义了6个方法

springboot使用TaskScheduler实现动态增删启停定时任务方式

接口的6种方法

public interface TaskScheduler { 

/** 
* 提交任务调度请求 
* @param task　待执行任务　　 
* @param trigger 使用Trigger指定任务调度规则 
* @return 
*/
ScheduledFuture schedule(Runnable task, Trigger trigger);

/** 
* 提交任务调度请求 
* 注意任务只执行一次，使用startTime指定其启动时间  
* @param task　待执行任务 
* @param startTime 任务启动时间 
* @return 
*/
ScheduledFuture schedule(Runnable task, Date startTime);


/** 
* 使用fixedRate的方式提交任务调度请求 
* 任务首次启动时间由传入参数指定 
* @param task　待执行的任务　 
* @param startTime　任务启动时间 
* @param period　两次任务启动时间之间的间隔时间，默认单位是毫秒 
* @return 
*/
ScheduledFuture scheduleAtFixedRate(Runnable task, Date startTime, long period);

/** 
* 使用fixedRate的方式提交任务调度请求 
* 任务首次启动时间未设置，任务池将会尽可能早的启动任务 
* @param task 待执行任务 
* @param period 两次任务启动时间之间的间隔时间，默认单位是毫秒 
* @return 
*/
ScheduledFuture scheduleAtFixedRate(Runnable task, long period);

/** 
* 使用fixedDelay的方式提交任务调度请求 
* 任务首次启动时间由传入参数指定 
* @param task 待执行任务 
* @param startTime 任务启动时间 
* @param delay 上一次任务结束时间与下一次任务开始时间的间隔时间，单位默认是毫秒 
* @return 
*/
ScheduledFuture scheduleWithFixedDelay(Runnable task, Date startTime, long delay);

/** 
* 使用fixedDelay的方式提交任务调度请求 
* 任务首次启动时间未设置，任务池将会尽可能早的启动任务 
* @param task 待执行任务 
* @param delay 上一次任务结束时间与下一次任务开始时间的间隔时间，单位默认是毫秒 
* @return 
*/
ScheduledFuture scheduleWithFixedDelay(Runnable task, long delay);
}

0、ThreadPoolTaskScheduler

在 ThreadPoolTaskSchedulerConfig 中定义 ThreadPoolTaskScheduler bean

@Configuration
public class ThreadPoolTaskSchedulerConfig {

    @Bean
    public ThreadPoolTaskScheduler threadPoolTaskScheduler(){
        ThreadPoolTaskScheduler threadPoolTaskScheduler
          = new ThreadPoolTaskScheduler();
        threadPoolTaskScheduler.setPoolSize(5);
        threadPoolTaskScheduler.setThreadNamePrefix(
          "ThreadPoolTaskScheduler");
        return threadPoolTaskScheduler;
    }
}

配置的 bean threadPoolTaskScheduler 可以根据配置的池大小 5 异步执行任务。

请注意，所有与 ThreadPoolTaskScheduler 相关的线程名称都将以ThreadPoolTaskScheduler 为前缀。

让我们实现一个简单的任务，然后我们可以安排：

class RunnableTask implements Runnable{
    private String message;
    
    public RunnableTask(String message){
        this.message = message;
    }
    
    @Override
    public void run() {
        System.out.println(new Date()+" Runnable Task with "+message
          +" on thread "+Thread.currentThread().getName());
    }
}

1、schedule(Runnable task, Trigger trigger)

指定一个触发器执行定时任务。可以使用CronTrigger来指定Cron表达式，执行定时任务

如下：使用CronTrigger 来根据 cron 表达式调度任务，可以使用提供的触发器按照某个指定的节奏或时间表运行任务，在这种情况下，RunnableTask 将在每分钟的第 10 秒执行。

taskScheduler.schedule(new RunnableTask("Cron Trigger"), cronTrigger);

2、schedule(Runnable task, Date startTime);

指定一个具体时间点执行定时任务，可以动态的指定时间，开启任务，只执行一次

如下：配置一个任务在 1000 毫秒的固定延迟后运行，RunnableTask 将始终在一次执行完成和下一次执行开始之间运行 1000 毫秒。

taskScheduler.schedule(
  new Runnabletask("Specific time, 3 Seconds from now"),
  new Date(System.currentTimeMillis + 3000)
);

3、scheduleAtFixedRate(Runnable task, long period);

立即执行，循环任务，指定一个执行周期（毫秒计时）

PS:不管上一个周期是否执行完，到时间下个周期就开始执行

如下：安排一个任务以固定的毫秒速率运行，下一个 RunnableTask 将始终在 2000 毫秒后运行，而不管上次执行的状态如何，它可能仍在运行。

taskScheduler.scheduleAtFixedRate(
  new RunnableTask("Fixed Rate of 2 seconds") , 
  2000);

4、scheduleAtFixedRate(Runnable task, Date startTime, long period);

指定时间开始执行，循环任务，指定一个间隔周期（毫秒计时）

PS:不管上一个周期是否执行完，到时间下个周期就开始执行

taskScheduler.scheduleAtFixedRate(new RunnableTask(
  "Fixed Rate of 2 seconds"), new Date(), 3000);

5、scheduleWithFixedDelay(Runnable task, long delay);

立即执行，循环任务，指定一个间隔周期（毫秒计时）

PS:上一个周期执行完，等待delay时间，下个周期开始执行

如下：配置一个任务在 1000 毫秒的固定延迟后运行，RunnableTask 将始终在一次执行完成和下一次执行开始之间运行 1000 毫秒。

taskScheduler.scheduleWithFixedDelay(
  new RunnableTask("Fixed 1 second Delay"), 
  1000);

6、scheduleWithFixedDelay(Runnable task, Date startTime, long delay);

指定时间开始执行，循环任务，指定一个间隔周期（毫秒计时）

PS:上一个周期执行完，等待delay时间，下个周期开始执行

如下：将任务配置为在给定开始时间的固定延迟后运行，RunnableTask 将在指定的执行时间被调用，其中包括 @PostConstruct 方法开始的时间，随后延迟 1000 毫秒。

taskScheduler.scheduleWithFixedDelay(
  new RunnableTask("Current Date Fixed 1 second Delay"),
  new Date(),
  1000);

接口5个实现类

springboot使用TaskScheduler实现动态增删启停定时任务方式

1、ConcurrentTaskScheduler

以当前线程执行任务，如果任务简单，可以直接使用这个类来执行，快捷方便

单线程运行

public class LocTest implements Runnable {
  private ConcurrentTaskScheduler concurrentTaskScheduler = new ConcurrentTaskScheduler();
  private void start() {
    concurrentTaskScheduler.schedule(this, new Date());
  }
  public void run() {
    Thread thread = Thread.currentThread();
    System.out.println("current id:" + thread.getId());
    System.out.println("current name:" + thread.getName());
  }
  public static void main(String[] args) {
    new LocTest().start();
  }
}

2、DefaultManagedTaskScheduler

以当前线程执行任务，是ConcurrentTaskScheduler的子类，添加了JNDI的支持。

和ConcurrentTaskScheduler一样的用法，需要使用JNDI可以单独设置

3、ThreadPoolTaskScheduler

TaskScheduler接口的默认实现类，多线程定时任务执行。可以设置执行线程池数（默认一个线程）

使用前必须得先调用initialize()【初始化方法】
有shutDown()方法，执行完后可以关闭线程

除实现了TaskScheduler接口中的方法外，它还包含了一些对ScheduledThreadPoolExecutor进行操作的接口，其常用方法如下：

setPoolSize：设置线程池大小，最小为1，默认情况下也为1；
setErrorHandler ：设置异常处理器。
getScheduledThreadPoolExecutor ：获取ScheduledExecutor，默认ScheduledThreadPoolExecutor类型。
getActiveCount ：获取当前活动的线程数
execute ：提交执行一次的任务
submit\submitListenable ：提交执行一次的任务，并且返回一个Future对象供判断任务状态使用

public class LocTest implements Runnable {
	private ThreadPoolTaskScheduler taskScheduler = new ThreadPoolTaskScheduler();
	private void start() {
		taskScheduler.setPoolSize(10);
		//必须得先初始化，才能使用
		taskScheduler.initialize();
		taskScheduler.schedule(this, new Date());
	}
	public void run() {
		Thread ct = Thread.currentThread();
		System.out.println("current id:"+ct.getId());
		System.out.println("current name:"+ct.getName());
	}
	public static void main(String[] args) {
		new LocTest().start();
	}
}

4、TimerManagerTaskScheduler

用于包装CommonJ中的TimerManager接口。

在使用CommonJ进行调度时使用