SpringBoot+schedule+可以动态添加或删除定时任务

基于注解模式

1. 使用 @Scheduled(cron=“0 0 1 * * ?”) 注解（此处cron表达式为每天凌晨一点执行）
2. 注意，使用此注解时，若不加 @Async 那么就会是单线程的，多任务时会阻塞，例如A任务1点执行，B任务1点10分执行，若A一直执行到1点10分，那么B任务就会被阻塞，不执行了。
3. 上代码：

@SpringBootApplication
//开启定时
@EnableScheduling
@MapperScan(basePackages = { "com.XXX.XXX.maintenancecenter.mapper" })
public class StartApp {
	public static void main(String[] args) {
		SpringApplication.run(StartApp.class, args);
	}
}

@Component
//@Async
public class ScheduleTask{

    /**默认是fixedDelay 上一次执行完毕时间后执行下一轮*/
    @Scheduled(cron = "0/5 * * * * *")
    public void run() throws InterruptedException {
        Thread.sleep(6000);
        System.out.println(Thread.currentThread().getName()+"=====>>>>>使用cron  {}"+(System.currentTimeMillis()/1000));
    }

    /**fixedRate:上一次开始执行时间点之后5秒再执行*/
    @Scheduled(fixedRate = 5000)
    public void run1() throws InterruptedException {
        Thread.sleep(6000);
        System.out.println(Thread.currentThread().getName()+"=====>>>>>使用fixedRate  {}"+(System.currentTimeMillis()/1000));
    }

    /**fixedDelay:上一次执行完毕时间点之后5秒再执行*/
    @Scheduled(fixedDelay = 5000)
    public void run2() throws InterruptedException {
        Thread.sleep(7000);
        System.out.println(Thread.currentThread().getName()+"=====>>>>>使用fixedDelay  {}"+(System.currentTimeMillis()/1000));
    }

    /**第一次延迟2秒后执行，之后按fixedDelay的规则每5秒执行一次*/
    @Scheduled(initialDelay = 2000, fixedDelay = 5000)
    public void run3(){
        System.out.println(Thread.currentThread().getName()+"=====>>>>>使用initialDelay  {}"+(System.currentTimeMillis()/1000));
    }

基于接口的自定义线程模式

1.基于接口模式时，最重要的就是 SchedulingConfigurer ，自己定义线程池，不多说，直接上代码：

@Component
public class MyScheConfigurer implements SchedulingConfigurer {

	private final Logger logger = LoggerFactory.getLogger(this.getClass());

	private ScheduledTaskRegistrar taskRegistrar;

	private Set<ScheduledFuture<?>> scheduledFutures = null;

	private Map<String, ScheduledFuture<?>> taskFutures = new ConcurrentHashMap<String, ScheduledFuture<?>>();

	/** 每天凌晨1点执行 */
	@Value("${taskInfo.delTmpFile.delTmpFileCron}")
	String delTmpFileCron;

	/** 每天凌晨2点执行 */
	@Value("${taskInfo.clearTable.clearTableCron}")
	String clearTableCron;

	@Value("${taskInfo.clearTable.tableSchema}")
	String tableSchema;
	
	@Autowired
	MaintenanceCenterMapper dao;

	@Autowired
	MyScheConfigurer scheConfigurer;
	
	@Override
	public void configureTasks(ScheduledTaskRegistrar scheduledTaskRegistrar) {
		logger.info("configureTasks");
		
		List<TsTableClearRule> sortClearRules = sortClearRules();
		
		this.taskRegistrar = scheduledTaskRegistrar;
		this.taskRegistrar.setTaskScheduler(TP.getScheduleTP(sortClearRules.size()+1));
		
		//每天凌晨1点执行的删除临时文件任务
		logger.info("delTmpFileCron = "+delTmpFileCron);
		scheConfigurer.addTriggerTask("DELTMPFILE:"+delTmpFileCron, new TriggerTask(new DelTmpFileTask(dao), getTriggerByCron(delTmpFileCron)));
				
		//每天凌晨2点执行的删除临时表数据的任务
		sortClearRules.forEach(rule->{
			logger.info("rule = "+rule.toString());
			scheConfigurer.addTriggerTask(rule.getRuleId(), new TriggerTask(new ClearTableTask(dao,tableSchema, rule), getTriggerByCron(rule.getOpearTime())));
		});
		
	}

	private Set<ScheduledFuture<?>> getScheduledFutures() {
		if (scheduledFutures == null) {
			try {
				scheduledFutures = (Set<ScheduledFuture<?>>) BeanUtils.getProperty(taskRegistrar,  "scheduledTasks");
			} catch (NoSuchFieldException e) {
				throw new SchedulingException("not found scheduledFutures field.");
			}
		}
		return scheduledFutures;
	}

	/**
	 * 添加任务
	 * 
	 * @param taskId
	 * @param triggerTask
	 */
	public void addTriggerTask(String taskId, TriggerTask triggerTask) {
		if (taskFutures.containsKey(taskId)) {
			throw new SchedulingException("the taskId[" + taskId + "] was added.");
		}
		TaskScheduler scheduler = taskRegistrar.getScheduler();
		ScheduledFuture<?> future = scheduler.schedule(triggerTask.getRunnable(), triggerTask.getTrigger());
		getScheduledFutures().add(future);
		taskFutures.put(taskId, future);
	}

	/**
	 * 取消任务
	 * 
	 * @param taskId
	 */
	public void cancelTriggerTask(String taskId) {
		ScheduledFuture<?> future = taskFutures.get(taskId);
		if (future != null) {
			future.cancel(true);
		}
		taskFutures.remove(taskId);
		getScheduledFutures().remove(future);
	}

	/**
	 * 重置任务
	 * 
	 * @param taskId
	 * @param triggerTask
	 */
	public void resetTriggerTask(String taskId, TriggerTask triggerTask) {
		cancelTriggerTask(taskId);
		addTriggerTask(taskId, triggerTask);
	}

	/**
	 * 任务编号
	 * 
	 * @return
	 */
	public Set<String> taskIds() {
		return taskFutures.keySet();
	}

	/**
	 * 是否存在任务
	 * 
	 * @param taskId
	 * @return
	 */
	public boolean hasTask(String taskId) {
		return this.taskFutures.containsKey(taskId);
	}

	/**
	 * 任务调度是否已经初始化完成
	 * 
	 * @return
	 */
	public boolean inited() {
		return this.taskRegistrar != null && this.taskRegistrar.getScheduler() != null;
	}

	/**
	 * 初始化数据库数据
	 * @return
	 */
	private  List<TsTableClearRule> sortClearRules() {
		List<TsTableClearRule> rules = dao.selectTsTableClearRule();
		rules.forEach(rule -> {
			//暂时按照固定值来做
//			if (StringUtils.isBlank(rule.getOpearTime())){
				logger.info("rule = "+rule.toString());
				rule.setOpearTime(clearTableCron);
//			}
		});
		return rules;
	}
	
	/**
	 * 通过cron表达式获取触发器
	 * @param cron
	 * @return
	 */
	private Trigger getTriggerByCron(String cron) {
		Trigger trigger = new Trigger() {
			@Override
			public Date nextExecutionTime(TriggerContext triggerContext) {
				// 任务触发，可修改任务的执行周期.
				CronTrigger trigger = new CronTrigger(cron);
				Date nextExec = trigger.nextExecutionTime(triggerContext);
				return nextExec;
			}
		};
		return trigger;
	}
	
}

public class TP {
	/**
	 * 将queueSize=1，尽可能保持按任务提交顺序进行执行！
	 * 
	 * @param maximumPoolSize
	 *            线程池峰值线程个数
	 * @return ThreadPoolExecutor
	 */
	public static ThreadPoolExecutor getTP(int maximumPoolSize) {
		return (new ThreadPoolExecutor(maximumPoolSize / 10 + 1, maximumPoolSize, 2, TimeUnit.SECONDS,
				new ArrayBlockingQueue<Runnable>(1), new CallerRunsPolicy()));

		// return (new ThreadPoolExecutor(maxPoolSize , maxPoolSize, 0,
		// TimeUnit.SECONDS,
		// new ArrayBlockingQueue<Runnable>(maxPoolSize + 5), new
		// ThreadPoolExecutor.CallerRunsPolicy()));
	}

	/**
	 * 
	 * @param maximumPoolSize
	 *            线程池峰值线程个数
	 * @return ThreadPoolExecutor
	 */
	public static ThreadPoolTaskScheduler getScheduleTP(int maximumPoolSize) {
		ThreadPoolTaskScheduler taskScheduler = new ThreadPoolTaskScheduler();
		taskScheduler.setPoolSize(maximumPoolSize);
		taskScheduler.setThreadNamePrefix("TaskScheduler-ThreadPool-");
		// 线程池对拒绝任务（无线程可用）的处理策略，目前只支持AbortPolicy、CallerRunsPolicy；默认为后者
		taskScheduler.setRejectedExecutionHandler(new CallerRunsPolicy());
		// 调度器shutdown被调用时等待当前被调度的任务完成
		taskScheduler.setWaitForTasksToCompleteOnShutdown(true);
		// 等待时长
		taskScheduler.setAwaitTerminationSeconds(60);
		taskScheduler.initialize();
		return taskScheduler;
	}

	/**
	 * 
	 * @param maximumPoolSize
	 *            线程池峰值线程个数
	 * @return ThreadPoolExecutor
	 */
	public static ThreadPoolTaskExecutor getExecutorTP(int maximumPoolSize) {
		ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
		taskExecutor.setCorePoolSize(maximumPoolSize / 10 + 1);
		taskExecutor.setMaxPoolSize(maximumPoolSize);
		taskExecutor.setThreadNamePrefix("TaskExecutor-ThreadPool-");
		// 线程池对拒绝任务（无线程可用）的处理策略，目前只支持AbortPolicy、CallerRunsPolicy；默认为后者
		taskExecutor.setRejectedExecutionHandler(new CallerRunsPolicy());
		// 调度器shutdown被调用时等待当前被调度的任务完成
		taskExecutor.setWaitForTasksToCompleteOnShutdown(true);
		// 等待时长
		taskExecutor.setAwaitTerminationSeconds(60);
		taskExecutor.initialize();
		return taskExecutor;
	}

	
	/**
	 * @param maximumPoolSize
	 *            线程池峰值线程个数
	 * @param queueSize
	 *            线程池ArrayBlockingQueue大小
	 * @return ThreadPoolExecutor
	 */
	public static ThreadPoolExecutor getTP(int maximumPoolSize, int queueSize) {
		return (new ThreadPoolExecutor(maximumPoolSize / 10 + 1, maximumPoolSize, 2, TimeUnit.SECONDS,
				new ArrayBlockingQueue<Runnable>(queueSize), new CallerRunsPolicy()));
	}

	/**
	 * @param corePoolSize
	 *            线程池初始线程个数
	 * @param maximumPoolSize
	 *            线程池峰值线程个数
	 * @param queueSize
	 *            线程池ArrayBlockingQueue大小
	 * @return ThreadPoolExecutor
	 */
	public static ThreadPoolExecutor getTP(int corePoolSize, int maximumPoolSize, int queueSize) {
		return (new ThreadPoolExecutor(corePoolSize, maximumPoolSize, 2, TimeUnit.SECONDS,
				new ArrayBlockingQueue<Runnable>(queueSize), new CallerRunsPolicy()));
	}

	/**
	 * A handler for rejected tasks that runs the rejected task directly in the
	 * calling thread of the {@code execute} method, unless the executor has
	 * been shut down, in which case the task is discarded.
	 */
	public static class CallerRunsPolicy implements RejectedExecutionHandler {
		/**
		 * Creates a {@code CallerRunsPolicy}.
		 */
		public CallerRunsPolicy() {
		}

		/**
		 * Executes task r in the caller's thread, unless the executor has been
		 * shut down, in which case the task is discarded.
		 * 
		 * @param r
		 *            the runnable task requested to be executed
		 * @param e
		 *            the executor attempting to execute this task
		 */
		public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
			try {
				e.getQueue().put(r);
			} catch (InterruptedException e1) {
				e1.printStackTrace();
			}
			// if (!e.isShutdown()) {
			// r.run();
			// }
		}
	}

}

public class BeanUtils {

	public static Field findField(Class<?> clazz, String name) {
		try {
			return clazz.getField(name);
		} catch (NoSuchFieldException ex) {
			return findDeclaredField(clazz, name);
		}
	}

	public static Field findDeclaredField(Class<?> clazz, String name) {
		try {
			return clazz.getDeclaredField(name);
		} catch (NoSuchFieldException ex) {
			if (clazz.getSuperclass() != null) {
				return findDeclaredField(clazz.getSuperclass(), name);
			}
			return null;
		}
	}

	public static Method findMethod(Class<?> clazz, String methodName, Class<?>... paramTypes) {
		try {
			return clazz.getMethod(methodName, paramTypes);
		} catch (NoSuchMethodException ex) {
			return findDeclaredMethod(clazz, methodName, paramTypes);
		}
	}

	public static Method findDeclaredMethod(Class<?> clazz, String methodName, Class<?>... paramTypes) {
		try {
			return clazz.getDeclaredMethod(methodName, paramTypes);
		} catch (NoSuchMethodException ex) {
			if (clazz.getSuperclass() != null) {
				return findDeclaredMethod(clazz.getSuperclass(), methodName, paramTypes);
			}
			return null;
		}
	}

	public static Object getProperty(Object obj, String name) throws NoSuchFieldException {
		Object value = null;
		Field field = findField(obj.getClass(), name);
		if (field == null) {
			throw new NoSuchFieldException("no such field [" + name + "]");
		}
		boolean accessible = field.isAccessible();
		field.setAccessible(true);
		try {
			value = field.get(obj);
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
		field.setAccessible(accessible);
		return value;
	}

	public static void setProperty(Object obj, String name, Object value) throws NoSuchFieldException {
		Field field = findField(obj.getClass(), name);
		if (field == null) {
			throw new NoSuchFieldException("no such field [" + name + "]");
		}
		boolean accessible = field.isAccessible();
		field.setAccessible(true);
		try {
			field.set(obj, value);
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
		field.setAccessible(accessible);
	}

	public static Map<String, Object> obj2Map(Object obj, Map<String, Object> map) {
		if (map == null) {
			map = new HashMap<String, Object>();
		}
		if (obj != null) {
			try {
				Class<?> clazz = obj.getClass();
				do {
					Field[] fields = clazz.getDeclaredFields();
					for (Field field : fields) {
						int mod = field.getModifiers();
						if (Modifier.isStatic(mod)) {
							continue;
						}
						boolean accessible = field.isAccessible();
						field.setAccessible(true);
						map.put(field.getName(), field.get(obj));
						field.setAccessible(accessible);
					}
					clazz = clazz.getSuperclass();
				} while (clazz != null);
			} catch (Exception e) {
				throw new RuntimeException(e);
			}
		}
		return map;
	}

	/**
	 * 获得父类集合，包含当前class
	 * 
	 * @param clazz
	 * @return
	 */
	public static List<Class<?>> getSuperclassList(Class<?> clazz) {
		List<Class<?>> clazzes = new ArrayList<Class<?>>(3);
		clazzes.add(clazz);
		clazz = clazz.getSuperclass();
		while (clazz != null) {
			clazzes.add(clazz);
			clazz = clazz.getSuperclass();
		}
		return Collections.unmodifiableList(clazzes);
	}
}

建议使用第二种方式，可以动态从数据库中获取cron，然后生成task任务，也可以动态关闭，添加，任务。