如何优雅的实现 SpringBoot 并行任务

第一种：把参数配置到.properties文件中：

代码：

1. import java.text.SimpleDateFormat;
2. import java.util.Date;
4. import org.springframework.scheduling.annotation.Scheduled;
5. import org.springframework.stereotype.Component;
7. /**
8. * 从配置文件加载任务信息
9. */
10. @Component
11. public class ScheduledTask {
13.    private static final SimpleDateFormat dateFormat = new SimpleDateFormat("HH:mm:ss");
15.    //@Scheduled(fixedDelayString = "${jobs.fixedDelay}")
16.    @Scheduled(fixedDelayString = "2000")
17.    public void getTask1() {
18.        System.out.println("任务1,从配置文件加载任务信息，当前时间：" + dateFormat.format(new Date()));
19.    }
21.    @Scheduled(cron = "${jobs.cron}")
22.    public void getTask2() {
23.        System.out.println("任务2,从配置文件加载任务信息，当前时间：" + dateFormat.format(new Date()));
24.    }
25. }

application.properties文件：

1. jobs.fixedDelay=5000
2. jobs.cron=0/5 * *  * * ?

SpringBootCron2Application.java中：

1. import org.springframework.boot.SpringApplication;
2. import org.springframework.boot.autoconfigure.SpringBootApplication;
3. import org.springframework.scheduling.annotation.EnableScheduling;
5. @SpringBootApplication
6. @EnableScheduling
7. public class SpringBootCron2Application {
8.    public static void main(String[] args) {
9.        SpringApplication.run(SpringBootCron2Application.class, args);
10.    }
11. }

注：@EnableScheduling 这个一定要加上；否则，不会定时启动任务！

@Scheduled中的参数说明：

• **@Scheduled(fixedRate=2000)**：上一次开始执行时间点后2秒再次执行；
• **@Scheduled(fixedDelay=2000)**：上一次执行完毕时间点后2秒再次执行；
• **@Scheduled(initialDelay=1000, fixedDelay=2000)**：第一次延迟1秒执行，然后在上一次执行完毕时间点后2秒再次执行；
• **@Scheduled(cron="* * * * * ?")**：按cron规则执行。

在线Cron表达式生成器：http://cron.qqe2.com/

第二种定时任务：单线程和多线程

1、创建定时任务：

1. import org.slf4j.Logger;
2. import org.slf4j.LoggerFactory;
3. import org.springframework.scheduling.annotation.Scheduled;
4. import org.springframework.stereotype.Component;
6. /**
7. * 构建执行定时任务
8. * TODO
9. */
10. @Component
11. public class ScheduledTask2 {
13.    private Logger logger = LoggerFactory.getLogger(ScheduledTask2.class);
15.    private int fixedDelayCount = 1;
16.    private int fixedRateCount = 1;
17.    private int initialDelayCount = 1;
18.    private int cronCount = 1;
20.    @Scheduled(fixedDelay = 5000)        //fixedDelay = 5000表示当前方法执行完毕5000ms后，Spring scheduling会再次调用该方法
21.    public void testFixDelay() {
22.        logger.info("===fixedDelay: 第{}次执行方法", fixedDelayCount++);
23.    }
25.    @Scheduled(fixedRate = 5000)        //fixedRate = 5000表示当前方法开始执行5000ms后，Spring scheduling会再次调用该方法
26.    public void testFixedRate() {
27.        logger.info("===fixedRate: 第{}次执行方法", fixedRateCount++);
28.    }
30.    @Scheduled(initialDelay = 1000, fixedRate = 5000)   //initialDelay = 1000表示延迟1000ms执行第一次任务
31.    public void testInitialDelay() {
32.        logger.info("===initialDelay: 第{}次执行方法", initialDelayCount++);
33.    }
35.    @Scheduled(cron = "0 0/1 * * * ?")  //cron接受cron表达式，根据cron表达式确定定时规则
36.    public void testCron() {
37.        logger.info("===initialDelay: 第{}次执行方法", cronCount++);
38.    }
40. }

使用 @Scheduled来创建定时任务 这个注解用来标注一个定时任务方法。

通过看 @Scheduled源码可以看出它支持多种参数：

• **cron**：cron表达式，指定任务在特定时间执行；
• **fixedDelay**：表示上一次任务执行完成后多久再次执行，参数类型为long，单位ms；
• **fixedDelayString**：与**fixedDelay**含义一样，只是参数类型变为String；
• **fixedRate**：表示按一定的频率执行任务，参数类型为long，单位ms；
• **fixedRateString**: 与**fixedRate**的含义一样，只是将参数类型变为String；
• **initialDelay**：表示延迟多久再第一次执行任务，参数类型为long，单位ms；
• **initialDelayString**：与**initialDelay**的含义一样，只是将参数类型变为String；
• **zone**：时区，默认为当前时区，一般没有用到。 2、开启定时任务：
  ```java import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.scheduling.annotation.EnableScheduling;

@SpringBootApplication @EnableScheduling public class SpringBootCron2Application { public static void main(String[] args) { SpringApplication.run(SpringBootCron2Application.class, args); } }

1. 注：这里的 `@EnableScheduling`  注解，它的作用是发现注解 `@Scheduled`的任务并由后台执行。没有它的话将无法执行定时任务。<br />引用官方文档原文：
2. > `@EnableScheduling` ensures that a background task executor is created. Without it, nothing gets scheduled.
4. <a name="nM655"></a>
5. #### 3、执行结果（单线程）
6. 就完成了一个简单的定时任务模型，从控制台输入的结果中可以看出所有的定时任务都是在同一个线程池用同一个线程来处理的，那么如何来并发的处理各定时任务呢，请继续向下看。
7. <a name="RXWwg"></a>
8. #### 4、多线程处理定时任务：
9. 看到控制台输出的结果，所有的定时任务都是通过一个线程来处理的，估计是在定时任务的配置中设定了一个`SingleThreadScheduledExecutor`，于是看了源码，从`ScheduledAnnotationBeanPostProcessor`类开始一路找下去。果然，在`ScheduledTaskRegistrar`（定时任务注册类）中的`ScheduleTasks`中又这样一段判断：
10. ```java
11. if (this.taskScheduler == null) {
12.    this.localExecutor = Executors.newSingleThreadScheduledExecutor();
13.    this.taskScheduler = new ConcurrentTaskScheduler(this.localExecutor);
14. }

这就说明如果taskScheduler为空，那么就给定时任务做了一个单线程的线程池，正好在这个类中还有一个设置taskScheduler的方法：

1. public void setScheduler(Object scheduler) {
2.    Assert.notNull(scheduler, "Scheduler object must not be null");
3.    if (scheduler instanceof TaskScheduler) {
4.        this.taskScheduler = (TaskScheduler) scheduler;
5.    }
6.    else if (scheduler instanceof ScheduledExecutorService) {
7.        this.taskScheduler = new ConcurrentTaskScheduler(((ScheduledExecutorService) scheduler));
8.    }
9.    else {
10.        throw new IllegalArgumentException("Unsupported scheduler type: " + scheduler.getClass());
11.    }
12. }

这样问题就很简单了，只需用调用这个方法显式的设置一个ScheduledExecutorService就可以达到并发的效果了。要做的仅仅是实现SchedulingConfigurer接口，重写configureTasks方法就OK了；

1. import org.springframework.context.annotation.Configuration;
2. import org.springframework.scheduling.annotation.SchedulingConfigurer;
3. import org.springframework.scheduling.config.ScheduledTaskRegistrar;
5. import java.util.concurrent.Executors;
7. /**
8. * 多线程执行定时任务
9. */
10. @Configuration
11. //所有的定时任务都放在一个线程池中，定时任务启动时使用不同都线程。
12. public class ScheduleConfig implements SchedulingConfigurer {
13.    @Override
14.    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
15.        //设定一个长度10的定时任务线程池
16.        taskRegistrar.setScheduler(Executors.newScheduledThreadPool(10));
17.    }
18. }

5、执行结果（并发）

通过控制台输出的结果看出每个定时任务都是在通过不同的线程来处理了。