【小家Spring】Spring任务调度核心接口(类)之---TaskScheduler（任务调度器）、Trigger（触发器）、ScheduledTask（调度任务）详解

//@since 3.0 我们发现每个方法都有可能返回null(比如首次执行)
public interface TriggerContext {
	// 上次预计的执行时间
	@Nullable
	Date lastScheduledExecutionTime();
	// 上次真正执行时间
	@Nullable
	Date lastActualExecutionTime();
	// 上次完成的时间
	@Nullable
	Date lastCompletionTime();

}

public interface Trigger {
	//获取下次执行时间
	@Nullable
	Date nextExecutionTime(TriggerContext triggerContext);
}

scheduler.schedule(task, new CronTrigger("0 15 9-17 * * MON-FRI"));

    public static void main(String[] args) {
        CronSequenceGenerator generator = new CronSequenceGenerator("0 15 * * * MON-FRI");

        Date next = generator.next(new Date());
        System.out.println(next); //Mon Apr 22 17:15:00 CST 2019
        System.out.println(generator.next(next)); //Mon Apr 22 18:15:00 CST 2019

    }

	@Override
	public Date nextExecutionTime(TriggerContext triggerContext) {
		Date date = triggerContext.lastCompletionTime();
		// 这里面有个处理：如果data为null，相当于任务已经完成了
		if (date != null) {
			// 拿到上一次预定执行的时间
			Date scheduled = triggerContext.lastScheduledExecutionTime();
			// 如果预定执行的时间为null（比如第一次）或者上一次还在data之后，那就取当前时间嘛
			if (scheduled != null && date.before(scheduled)) {
				// Previous task apparently executed too early...
				// Let's simply use the last calculated execution time then,
				// in order to prevent accidental re-fires in the same second.
				date = scheduled;
			}
		}
		// 如果任务还没有完成，那就以当前时间去计算下一个时间
		else {
			date = new Date();
		}
		return this.sequenceGenerator.next(date);
	}

public interface TaskScheduler {

	// 提交任务调度请求 
	// Runnable task：待执行得任务
	// Trigger trigger：使用Trigger指定任务调度规则
	@Nullable
	ScheduledFuture<?> schedule(Runnable task, Trigger trigger);

	// @since 5.0  这里使用的Instant 类，其实最终也是转换成了Date
	default ScheduledFuture<?> schedule(Runnable task, Instant startTime) {
		return schedule(task, Date.from(startTime));
	}
	//  提交任务调度请求   startTime表示它的执行时间
	//  注意任务只执行一次，使用startTime指定其启动时间  
	ScheduledFuture<?> schedule(Runnable task, Date startTime);

	// @since 5.0
	default ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period) {
		return scheduleAtFixedRate(task, Date.from(startTime), period.toMillis());
	}
	// 使用fixedRate的方式提交任务调度请求    任务首次启动时间由传入参数指定 
	// task　待执行的任务　 startTime　任务启动时间    period　两次任务启动时间之间的间隔时间，默认单位是毫秒
	ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period);

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

	// @since 5.0
	default ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay) {
		return scheduleWithFixedDelay(task, Date.from(startTime), delay.toMillis());
	}
	//  使用fixedDelay的方式提交任务调度请求  任务首次启动时间由传入参数指定 
	// delay 上一次任务结束时间与下一次任务开始时间的间隔时间，单位默认是毫秒 
	ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay);
	// @since 5.0
	default ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay) {
		return scheduleWithFixedDelay(task, delay.toMillis());
	}
	// 使用fixedDelay的方式提交任务调度请求 任务首次启动时间未设置，任务池将会尽可能早的启动任务 
	// delay 上一次任务结束时间与下一次任务开始时间的间隔时间，单位默认是毫秒 
	ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay);

}

public class ThreadPoolTaskScheduler extends ExecutorConfigurationSupport
		implements AsyncListenableTaskExecutor, SchedulingTaskExecutor, TaskScheduler {
	...
	// 默认的size 是1
	private volatile int poolSize = 1;
	private volatile boolean removeOnCancelPolicy = false;
	@Nullable
	private volatile ErrorHandler errorHandler;
	// 内部持有一个JUC的ScheduledExecutorService 的引用
	@Nullable
	private ScheduledExecutorService scheduledExecutor;
	...
	
	// 初始化线程池的执行器~~~~ 该方法的父类是ExecutorConfigurationSupport
	// 它定义了一些线程池的默认配置~~~~~
	@Override
	protected ExecutorService initializeExecutor(
			ThreadFactory threadFactory, RejectedExecutionHandler rejectedExecutionHandler) {
		// 我们发现，如果set PoolSize，那么它的size就是1
		this.scheduledExecutor = createExecutor(this.poolSize, threadFactory, rejectedExecutionHandler);

		if (this.removeOnCancelPolicy) {
			if (this.scheduledExecutor instanceof ScheduledThreadPoolExecutor) {
				((ScheduledThreadPoolExecutor) this.scheduledExecutor).setRemoveOnCancelPolicy(true);
			} else {
				logger.info("Could not apply remove-on-cancel policy - not a Java 7+ ScheduledThreadPoolExecutor");
			}
		}

		return this.scheduledExecutor;
	}
	// 就是new一个ScheduledThreadPoolExecutor  来作为最终执行任务的执行器
	protected ScheduledExecutorService createExecutor(
			int poolSize, ThreadFactory threadFactory, RejectedExecutionHandler rejectedExecutionHandler) {

		return new ScheduledThreadPoolExecutor(poolSize, threadFactory, rejectedExecutionHandler);
	}
	...
	
	//获取当前活动的线程数 委托给ScheduledThreadPoolExecutor来做得
	public int getActiveCount() {
		if (this.scheduledExecutor == null) {
			// Not initialized yet: assume no active threads.
			return 0;
		}
		return getScheduledThreadPoolExecutor().getActiveCount();
	}

	// 显然最终就是交给ScheduledThreadPoolExecutor去执行了~~~
	// 提交执行一次的任务
	// submit\submitListenable方法表示：提交执行一次的任务，并且返回一个Future对象供判断任务状态使用
	@Override
	public void execute(Runnable task) {
		Executor executor = getScheduledExecutor();
		try {
			executor.execute(errorHandlingTask(task, false));
		}
		catch (RejectedExecutionException ex) {
			throw new TaskRejectedException("Executor [" + executor + "] did not accept task: " + task, ex);
		}
	}
	...

}

    public static void main(String[] args) {
        ThreadPoolTaskScheduler taskScheduler = new ThreadPoolTaskScheduler();
        taskScheduler.setPoolSize(2);
        taskScheduler.initialize(); // 务必调用此方法来启动

        // 执行任务
        // 执行一次
        taskScheduler.execute(() -> System.out.println(Thread.currentThread().getName() + "  我只会被执行一次~~~"));
        // 周期性执行
        taskScheduler.schedule(() -> System.out.println(Thread.currentThread().getName() + " 我会被多次执行~~~"), new CronTrigger("0/2 * * * * ?"));

        // 此处：若你有周期性的任务，这里不要shutdown()
        //taskScheduler.shutdown();
    }

ThreadPoolTaskScheduler-1  我只会被执行一次~~~
ThreadPoolTaskScheduler-1 我会被多次执行~~~
ThreadPoolTaskScheduler-2 我会被多次执行~~~
ThreadPoolTaskScheduler-2 我会被多次执行~~~
ThreadPoolTaskScheduler-2 我会被多次执行~~~
ThreadPoolTaskScheduler-1 我会被多次执行~~~
ThreadPoolTaskScheduler-2 我会被多次执行~~~
ThreadPoolTaskScheduler-2 我会被多次执行~~~

    public static void main(String[] args) {
        ConcurrentTaskScheduler taskScheduler = new ConcurrentTaskScheduler();

        // 执行任务
        // 执行一次
        taskScheduler.execute(() -> System.out.println(Thread.currentThread().getName() + "  我只会被执行一次~~~"));
        // 周期性执行
        taskScheduler.schedule(() -> System.out.println(Thread.currentThread().getName() + " 我会被多次执行~~~"), new CronTrigger("0/2 * * * * ?"));

        // 此处：若你有周期性的任务，这里不要shutdown()
        //taskScheduler.shutdown();
    }

pool-2-thread-1  我只会被执行一次~~~
pool-3-thread-1 我会被多次执行~~~
pool-3-thread-1 我会被多次执行~~~
pool-3-thread-1 我会被多次执行~~~
pool-3-thread-1 我会被多次执行~~~
pool-3-thread-1 我会被多次执行~~~

// @since 4.3  发现这个类出现得还是比较晚得
public final class ScheduledTask {
	// 任务，其实就是很简单的包装了 Runnable。
	// 常见的子类有 TriggerTask、CronTask（主要是支持的CronTrigger、cron表达式）、
	// FixedDelayTask、FixedRateTask、IntervalTask(前两者得父类)
	private final Task task;
	@Nullable
	volatile ScheduledFuture<?> future;

	ScheduledTask(Task task) {
		this.task = task;
	}
	 //@since 5.0.2
	public Task getTask() {
		return this.task;
	}
	// 取消任务
	public void cancel() {
		ScheduledFuture<?> future = this.future;
		if (future != null) {
			future.cancel(true);
		}
	}
	@Override
	public String toString() {
		return this.task.toString();
	}
}