动态定时任务调度

一、 为什么要使用动态定时任务
现在的系统早已不是仅仅由增删改查组成，任务的定时调度和执行也是程序的标配。定时任务相当于闹钟，在什么时候做什么事情。定时任务实现方式，很多人都有不同的方式，基础无外乎以下四种：
1、 JDK的Timer类
2、 JDK的ScheduledExecutorService
3、 Spring Task
4、 Quartz
在使用过程中，用的最多的是SpringTask的XML配置，配置简单，也较好理解。但是有个缺点，在运行过程中想改变某个任务的执行时间频率或者是再增加/删除一个任务，怎么做？关闭应用，更改配置文件，重新启动！如果这种任务经常性变动，我们不可能频繁更改配置和重启应用的，这时动态定时任务有了用武之地。
二、 技术选型
近期在做项目的预警中心，运营人员在web页面进行增删改需要预警的内容和频率，服务端在接收到web请求后，添加、删除、修改定时任务。
在我的考虑中有三种方案实现，如下：
1、 启动一个定时任务，每隔一秒查询一次数据库，匹配到需要执行的任务，放入线程池执行；
2、 Spring ThreadPoolTaskScheduler，将任务ID和ScheduledFuture存入ConcurrentHashMap，通过任务ID获取ScheduledFuture，操作任务；
3、 Quartz-功能完善的任务调度框架；
方案一对数据库压力较大，频繁访问数据库，可能导致数据库性能低下，影响整个系统的性能。方案二中ThreadPoolTaskScheduler能够开启线程池进行任务调度，schedule方法返回ScheduledFuture，可以关闭其线程，符合我的预期，作为备选方案。方案三Quartz 是一个功能完善的任务调度框架，支持集群环境下的任务调度，使用也比较麻烦，做持久化的时候需要用到quartz的11张表，引入第三方框架会增加系统的复杂度，同时也增加了开发成本。
综上，我选择了方案二。
三、 实现原理
这里先介绍下ThreadPoolTaskScheduler是怎么实现对重复的任务进行调度。

ThreadPoolTaskScheduler其实底层使用也是java自带的线程池。


从下面的代码中可以看出最终执行的java.util.concurrent.ScheduledExecutorService定义的方法。executor正是上图createExecutor方法创建的ScheduledThreadPoolExecutor。

ThreadPoolTaskScheduler提供了以下6种方法进行定时任务发布：

1、public ScheduledFuture<?> schedule(Runnable task, Trigger trigger);//动态创建指定表达式cron的定时任务。
2、public ScheduledFuture<?> schedule(Runnable task, Date startTime);//在指定时间执行一次定时任务。
3、public ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period);//在指定时间(startTime)以指定间隔（period毫秒）执行一次任务，间隔为前一次执行开始到下一次任务执行。
4、public ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period);//从现在开始以指定间隔（period毫秒）执行一次任务，间隔为前一次执行开始到下一次任务执行。
5、public ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay);//在指定时间(startTime) 以指定间隔（delay毫秒）执行一次任务，间隔为前一次执行完成到下一次任务执行。
6、public ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay);//从现在开始以指定间隔（delay毫秒）执行一次任务，间隔为前一次执行完成到下一次任务执行。

根据业务场景，我采用的是第5种方式，代码如下：

1.	@Service  
2.	@Slf4j  
3.	public class AlertTaskInitServiceImpl implements IAlertTaskInitService {  
4.	  
5.	    /** 
6.	     * 线程池 
7.	     */  
8.	    @Autowired  
9.	    private ThreadPoolTaskScheduler threadPoolTaskScheduler;  
10.	  
11.	    /** 
12.	     * futureConcurrentMap 
13.	     */  
14.	    private ConcurrentMap<Long, ScheduledFuture> futureConcurrentMap = new ConcurrentHashMap<>();  
15.	  
16.	    /** 
17.	     * 开启定时任务 
18.	     * 
19.	     * @param alertRule 预警规则 
20.	     * @return 成功标记 
21.	     */  
22.	    @Override  
23.	    public boolean startTask(AlertRule alertRule) {  
24.	        boolean flag = false;  
25.	        long period = alertRule.getPeriod();  
26.	        Date startDate = new Date();  
27.	        BaseTask baseTask = new BaseTask();  
28.	        baseTask.setAlertRule(alertRule);  
29.	        future = threadPoolTaskScheduler.scheduleAtFixedRate(baseTask, startDate, period);  
30.	        futureConcurrentMap.put(id, future);  
31.	        log.info("预警规则 id:{} 添加任务成功", id);  
32.	        flag = true;  
33.	        return flag;  
34.	    }  
35.	  
36.	    /** 
37.	     * 关闭定时任务 
38.	     * 
39.	     * @param ruleId 规则ID 
40.	     * @return 成功标记 
41.	     */  
42.	    @Override  
43.	    public boolean stopTask(Long ruleId) {  
44.	        boolean flag = false;  
45.	        if (ruleId == null) {  
46.	            log.warn("预警规则ID为空");  
47.	            return flag;  
48.	        }  
49.	        ScheduledFuture future = futureConcurrentMap.get(ruleId);  
50.	        if (future == null){  
51.	            log.warn("预警future不存在");  
52.	            return true;  
53.	        }  
54.	        future.cancel(true);  
55.	        if (future.isCancelled()) {  
56.	            futureConcurrentMap.remove(ruleId);  
57.	            flag = true;  
58.	        }  
59.	        return flag;  
60.	    }  
61.	  
62.	    /** 
63.	     * 修改定时任务 
64.	     * 
65.	     * @param alertRule 预警规则 
66.	     * @return 成功标记 
67.	     */  
68.	    @Override  
69.	    public boolean updateTask(AlertRule alertRule) {  
70.	        if (alertRule == null) {  
71.	            log.warn("预警规则为空");  
72.	            return false;  
73.	        }  
74.	        boolean flag = stopTask(alertRule.getId());  
75.	        if (!flag) {  
76.	            return flag;  
77.	        }  
78.	        return startTask(alertRule);  
79.	    }  
80.	}

threadPoolTaskScheduler初始化如下：

<!--定时任务调度器-->  
<bean id="threadPoolTaskScheduler" class="org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler">  
	 <property name="rejectedExecutionHandler">  
	        <bean class="java.util.concurrent.ThreadPoolExecutor$AbortPolicy"/>  
	 </property>  
    <property name="threadNamePrefix" value="MesTaskThreadPool-"/>  
	<property name="waitForTasksToCompleteOnShutdown" value="true"/>  
	<property name="awaitTerminationSeconds" value="120"/>  
    <property name="poolSize" value="10"/>  
	<property name="removeOnCancelPolicy" value="true"/>  
</bean>

以上是我对本次使用动态定时任务调度的一点分析。技术没有优劣之分，每种技术都有适合的应用场景，在能解决问题的前提下，我认为越简单的技术越稳妥。