1. 原理
1.1 TaskScheduler
TaskScheduler是spring的定时任务使用的线程池的关键类
public interface TaskScheduler {
// 通过Trigger执行任务
ScheduledFuture schedule(Runnable task, Trigger trigger);
// 指定时间执行任务
ScheduledFuture schedule(Runnable task, Date startTime);
// 指定在指定时间后，循环周期执行任务
ScheduledFuture scheduleAtFixedRate(Runnable task, Date startTime, long period);
// 循环周期执行任务
ScheduledFuture scheduleAtFixedRate(Runnable task, long period);
// 延迟N时间，在指定日期执行
ScheduledFuture scheduleWithFixedDelay(Runnable task, Date startTime, long delay);
ScheduledFuture scheduleWithFixedDelay(Runnable task, long delay);
}1
2
3
4
5
6
7
8
9
10
11
12
13
141
2
3
4
5
6
7
8
9
10
11
12
13
14
TaskScheduler有两种实现方式：
- TimerManagerTaskScheduler：使用外部对象管理线程池，如 CommonJ TimerManager，适用于多个进程共享线程池
- ThreadPoolTaskScheduler： 如果仅仅在同一进程管理线程池，则推荐使用此对象。它实际使用Java自我的ScheduledExecutorService管理线程池
1.2 Trigger
Trigger是定时任务配置的关键类，配置方法的下次执行时间
public interface Trigger {
Date nextExecutionTime(TriggerContext triggerContext);
}1
2
31
2
3
方法里的参数TriggerContext是封装了任务最后执行的时间和最后执行完毕的时间
public interface TriggerContext {
Date lastScheduledExecutionTime();
Date lastActualExecutionTime();
Date lastCompletionTime();
}1
2
3
4
51
2
3
4
5
TriggerContext默认的实现是SimpleTriggerContext，看源码实现非常简单
Trigger的实现类：
- CronTrigger：使用cron表达式定义任务执行时机
如：scheduler.schedule(task, new CronTrigger("0 15 9-17 * * MON-FRI"));
- PeriodicTrigger：通过“fixed period,”，“initial delay value”，“boolean to indicate whether the period should be interpreted as a fixed-rate or a fixed-delay”3个参数配置任务执行的时机
2. 定时方法@Scheduled
通过@Scheduled定义定时任务
fixedDelay： 每次方法执行完毕后，等待Nms再执行此方法。
/**
* 每次方法执行完毕后，等待5s再执行此方法。
* 同时只能有个线程运行此方法
*/
@Scheduled(fixedDelay=5000)
public void fixedDelay() {
try {
// 执行方法需要10s
Thread.sleep(1000 * 10);
} catch (InterruptedException e) {
}
log.info("fixedDelay--");
}1
2
3
4
5
6
7
8
9
10
11
12
131
2
3
4
5
6
7
8
9
10
11
12
13
注意：定时方法返回值只能是void且不能有传入参数
fixedRate: 每隔5s调用一次此方法，无论之前的方法是否执行完毕
/**
* 每隔5s调用一次此方法，无论之前的方法是否执行完毕
* 同时可能有N个线程执行此方法
*
*/
@Scheduled(fixedRate=5000)
public void fixedRate() {
try {
// 执行方法需要10s
Thread.sleep(1000 * 10);
} catch (InterruptedException e) {
}
log.info("fixedRate--");
}1
2
3
4
5
6
7
8
9
10
11
12
13
141
2
3
4
5
6
7
8
9
10
11
12
13
14
initialDelay: 第一次调用此方法前的等待时间
/***
* initialDelay: 第一次调用此方法前的等待时间
*
*/
@Scheduled(initialDelay=1000, fixedRate=5000)
public void initialDelayAndfixedRate() {
log.info("initialDelayAndfixedRate--");
}1
2
3
4
5
6
7
81
2
3
4
5
6
7
8
cron：通过cron配置值
/**
* 支持cron语法：
* 每个参数的意义分别是： second, minute, hour, day of month, month, day of week
*
* 如下：周一至周五，每隔5s执行一次方法
*/
@Scheduled(cron="*/5 * * * * SUN-MON")
public void cron() {
log.info("cron--");
}1
2
3
4
5
6
7
8
9
101
2
3
4
5
6
7
8
9
10
完整的demo代码
/**
* 定时类
* 不同异步方法：定时方法只能返回void且不能接受任务参数
*
* @author hry
*
*/
@Component
public class ScheduleDemo {
private static final Logger log = Logger.getLogger(ScheduleDemo.class);
/**
* 每次方法执行完毕后，等待5s再执行此方法。
* 同时只能有个线程运行此方法
*/
@Scheduled(fixedDelay=5000)
public void fixedDelay() {
try {
// 执行方法需要10s
Thread.sleep(1000 * 10);
} catch (InterruptedException e) {
}
log.info("fixedDelay--");
}
/**
* 每隔5s调用一次此方法，无论之前的方法是否执行完毕
* 同时可能有N个线程执行此方法
*
*/
@Scheduled(fixedRate=5000)
public void fixedRate() {
try {
// 执行方法需要10s
Thread.sleep(1000 * 10);
} catch (InterruptedException e) {
}
log.info("fixedRate--");
}
/***
* initialDelay: 第一次调用此方法前的等待时间
*
*/
@Scheduled(initialDelay=1000, fixedRate=5000)
public void initialDelayAndfixedRate() {
log.info("initialDelayAndfixedRate--");
}
/**
* 支持cron语法：
* 每个参数的意义分别是： second, minute, hour, day of month, month, day of week
*
* 如下：周一至周五，每隔5s执行一次方法
*/
@Scheduled(cron="*/5 * * * * SUN-MON")
public void cron() {
log.info("cron--");
}
}1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
601
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
3. 定时方法启动方式
启动定时任务有以下方式
1. 注解
通过@EnableScheduling启动定时任务
```
@SpringBootApplication
@EnableScheduling // 启动定时任务
public class ScheduleApplicationWithAnnotation {
private static final Logger log = LoggerFactory.getLogger(ScheduleApplicationWithAnnotation.class);
/**
* 自定义定时任务线程池
* 如果没有，则使用默认定时任务池
* @return
*/
@Bean(destroyMethod="shutdown")
public Executor taskExecutor() {
return new ScheduledThreadPoolExecutor(10, new ThreadFactory() {
private AtomicInteger max = new AtomicInteger(0);
@Override
public Thread newThread(Runnable r) {
return new Thread(r, "mySchedulAnno-" + max.incrementAndGet());
}
});
}
public static void main(String[] args) {
log.info("Start ScheduleApplicationWithAnnotation.. ");
SpringApplication.run(ScheduleApplicationWithAnnotation.class, args);
}
}
```
2. XML配置
task:annotation-driven等价于@EnableScheduling，启动定时任务
task:annotation-driven等价于 @EnableScheduling， scheduler指定线程池
id指定线程池产生线程名称的前缀
```
/**
* 通过XML启动异步方法
* @author hry
*
*/
@SpringBootApplication
@ImportResource("classpath:/schedule/spring_schedule.xml")
public class ScheduleApplicationWithXML {
private static final Logger log = LoggerFactory.getLogger(ScheduleApplicationWithXML.class);
public static void main(String[] args) {
log.info("Start ScheduleApplicationWithXML.. ");
SpringApplication.run(ScheduleApplicationWithXML.class, args);
}
}
```
4. 自定义配置线程池
通过实现SchedulingConfigurer 对定时任务线程池进行更细化的配置
```
/**
* 通过实现SchedulingConfigurer对定时任务线程池进行更细致配置
* @author hry
*
*/
@Component
@Configuration
public class MySchedulingConfigurer implements SchedulingConfigurer {
@Override
public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
taskRegistrar.setScheduler(taskExecutor());
}
@Bean(destroyMethod="shutdown")
public Executor taskExecutor() {
return new ScheduledThreadPoolExecutor(10, new ThreadFactory() {
private AtomicInteger max = new AtomicInteger(0);
@Override
public Thread newThread(Runnable r) {
return new Thread(r, "myScheConfig-" + max.incrementAndGet());
}
});
}
}
```
通过@EnableScheduling启动定时方法
```
/**
* 通过@EnableScheduling启动定时方法
* 配置
*
* @author hry
*
*/
@SpringBootApplication
@EnableScheduling // 启动定时任务
public class ScheduleApplicationWithSchedulingConfigurer {
private static final Logger log = LoggerFactory.getLogger(ScheduleApplicationWithSchedulingConfigurer.class);
public static void main(String[] args) {
log.info("Start ScheduleApplicationWithSchedulingConfigurer.. ");
SpringApplication.run(ScheduleApplicationWithSchedulingConfigurer.class, args);
}
}
```
5. 代码
1679
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
