一、 为什么要使用动态定时任务
现在的系统早已不是仅仅由增删改查组成,任务的定时调度和执行也是程序的标配。定时任务相当于闹钟,在什么时候做什么事情。定时任务实现方式,很多人都有不同的方式,基础无外乎以下四种:
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>
以上是我对本次使用动态定时任务调度的一点分析。技术没有优劣之分,每种技术都有适合的应用场景,在能解决问题的前提下,我认为越简单的技术越稳妥。