springboot 定时任务@Scheduled 和 异步@Async

使用@EnableScheduling开启功能

@Configuration
@EnableScheduling
public class ScheduleConfig {
   

}

编写任务

@Component
public class ScheduledTasks {
   
    
     //表示上一次任务执行完成后多久再次执行，参数类型为long，单位ms;
     @Scheduled(fixedDelay = 500)
     public void fixedDelay(){
   
        
     }
     
     //表示按一定的频率执行任务，参数类型为long，单位ms;
     @Scheduled(fixedRate = 500)
     public void fixedRate(){
   
      
     }
  
     //cron表达式，指定任务在特定时间执行;
     @Scheduled(cron="0 50 * * * ?")
     public void cron(){
   
        
     }
     
     //第一次1秒后执行，当执行完后2秒再执行
     @Scheduled(initialDelay = 1000, fixedDelay = 2000)
     public void initialDelay() {
   

     }
     
     // 可以从配置文件中读取
     @Scheduled(fixedDelayString = "${jobs.fixedDelay}")
     public void fixedDelayString() {
   

     }

     
     /**
       * cron：cron表达式，指定任务在特定时间执行;
       * fixedDelay：表示上一次任务执行完成后多久再次执行，参数类型为long，单位ms;
       * fixedDelayString：与fixedDelay含义一样，只是参数类型变为String;
       * fixedRate：表示按一定的频率执行任务，参数类型为long，单位ms;
       * fixedRateString: 与fixedRate的含义一样，只是将参数类型变为String;
       * initialDelay：表示延迟多久再第一次执行任务，参数类型为long，单位ms;
       * initialDelayString：与initialDelay的含义一样，只是将参数类型变为String;
 	  */	
 }

 

配置（可选）

@Configuration
public class ScheduleConfig implements SchedulingConfigurer, AsyncConfigurer{
   
   
    //并行任务
    public void configureTasks(ScheduledTaskRegistrar taskRegistrar){
   
        TaskScheduler taskScheduler = taskScheduler();
        taskRegistrar.setTaskScheduler(taskScheduler);
    }

    
    //并行任务使用策略：多线程处理（配置线程数等）
    @Bean
    public ThreadPoolTaskScheduler taskScheduler(){
   
        ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();
        scheduler.setPoolSize(20);
        scheduler.setThreadNamePrefix("task-");  //设置线程名开头
        scheduler.setAwaitTerminationSeconds(60);
        scheduler.setWaitForTasksToCompleteOnShutdown(true);
        return scheduler;
    }

    //异步任务
    public Executor getAsyncExecutor(){
   
        Executor executor = taskScheduler();
        return executor;
    }

    //异步任务 异常处理
    public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler(){
   
    	return new SimpleAsyncUncaughtExceptionHandler();
    }
}

定时任务线程池中，不管配置多少个线程，每次到定时点，只有一个线程去执行任务。假如配置fixedDelay=500，表示上一次任务执行完后，延迟500毫秒执行下次任务。如果任务执行需要500毫秒，那么任务的执行周期是500+500=1000毫秒。就算线程池中有多个线程，也会等那个任务执行完再选取一个线程再次执行任务。

@Bean("aaa")
public TaskScheduler  scheduler() {
   
    ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();
    scheduler.setThreadNamePrefix("a");
    scheduler.setPoolSize(4);
    scheduler.initialize();
    return scheduler;
}


@Scheduled(fixedDelay = 500)
public void scheduled(){
   
    try {
   
        Thread.sleep(500);
    } catch (InterruptedException e) {
   
        e.printStackTrace();
    }
    LOGGER.info(Thread.currentThread().getName());
}

2018-10-11 10:18:44.705     com.demo.test.async.ScheduleService      : a1
2018-10-11 10:18:45.710     com.demo.test.async.ScheduleService      : a1
2018-10-