一。引入了spring-boot-starter包即可，无需额外jar包：

        <dependency>             <groupId>org.springframework.boot</groupId>             <artifactId>spring-boot-starter</artifactId>         </dependency>

二。启动类添加注解@EnableScheduling：

@SpringBootApplication//@EnableAutoConfiguration  @EnableScheduling//支持定时任务 public class SpringBootApplication {      public static void main(String[] args) {         SpringApplication.run(SpringBootApplication.class, args);     }  }

三。定时任务代码编写：

import org.springframework.scheduling.annotation.Scheduled; import org.springframework.stereotype.Component;  import java.util.Date;   @Component public class DemoSchedule {      @Scheduled(cron = "0 0/1 * * * ?")//每隔一分钟执行     public void test1() {         System.out.println("定时任务执行：" + new Date());     }      }

其中，cron表达式是spring内置支持的时间表达式，详解待续，可百度“在线cron”，帮你自动生成。 

上面使用的定时任务很简单，但是有缺点：

多个定时任务使用的是同一个调度线程，所以任务是阻塞执行的，执行效率不高。如果出现任务阻塞，导致一些场景的定时计算没有实际意义，比如每天12点的一个计算任务被阻塞到1点去执行，会导致结果并非我们想要的。

解决方式1：替换默认线程池，默认线程池只有一个线程：

@Configuration public class ScheduledConfig implements SchedulingConfigurer {      @Autowired     private TaskScheduler myThreadPoolTaskScheduler;      @Override     public void configureTasks(ScheduledTaskRegistrar scheduledTaskRegistrar) {         //简单粗暴的方式直接指定         //scheduledTaskRegistrar.setScheduler(Executors.newScheduledThreadPool(2));         //也可以自定义的线程池，方便线程的使用与维护         scheduledTaskRegistrar.setTaskScheduler(myThreadPoolTaskScheduler);     }      @Bean(name = "myThreadPoolTaskScheduler")     public TaskScheduler getMyThreadPoolTaskScheduler() {         ThreadPoolTaskScheduler taskScheduler = new ThreadPoolTaskScheduler();         taskScheduler.setPoolSize(20);//定时任务数量需小于池大小。否则，还是会有定时任务等待执行         taskScheduler.setThreadNamePrefix("taskScheduler-");         taskScheduler.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());         //调度器shutdown被调用时等待当前被调度的任务完成         taskScheduler.setWaitForTasksToCompleteOnShutdown(true);         //等待时长         taskScheduler.setAwaitTerminationSeconds(60);         return taskScheduler;     } }

解决方式2：方式一的本质改变了任务调度器默认使用的线程池，接下来这种是不改变调度器的默认线程池，而是把任务交给一个异步线程池去执行：

首先在启动类上添加@EnableAsync 注解开启异步任务支持
然后在定时任务的方法加上@Async即可，默认使用的线程池为SimpleAsyncTaskExecutor（该线程池默认来一个任务创建一个线程，就会不断创建大量线程，极有可能压爆服务器内存。当然它有自己的限流机制，这里就不多说了）
项目中为了更好的控制线程的使用，我们可以自定义我们自己的线程池，使用方式@Async("myThreadPool")

  @Scheduled(fixedRate = 1000*10,initialDelay = 1000*20)   @Async("myThreadPoolTaskExecutor")   //@Async   public void scheduledTest02(){       System.out.println(Thread.currentThread().getName()+"--->xxxxx--->"+Thread.currentThread().getId());   }    //自定义线程池   @Bean(name = "myThreadPoolTaskExecutor")   public TaskExecutor  getMyThreadPoolTaskExecutor() {       ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();       taskExecutor.setCorePoolSize(20);//定时任务能够同时执行的线程数。定时任务数量需小于池大小。否则，还是会有定时任务等待执行       taskExecutor.setMaxPoolSize(200);//定时任务能被同时调度的数量。调度后不一定马上执行，取决于上面的corePoolSize       taskExecutor.setQueueCapacity(25);       taskExecutor.setKeepAliveSeconds(200);       taskExecutor.setThreadNamePrefix("Haina-ThreadPool-");       // 线程池对拒绝任务（无线程可用）的处理策略，目前只支持AbortPolicy、CallerRunsPolicy；默认为后者       taskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());       //调度器shutdown被调用时等待当前被调度的任务完成       taskExecutor.setWaitForTasksToCompleteOnShutdown(true);       //等待时长       taskExecutor.setAwaitTerminationSeconds(60);       taskExecutor.initialize();       return taskExecutor;   }

上面能够解决多定时任务的阻塞问题，但如果多定时任务同时还是动态的呢？即cron表达式动态传入呢？

1.自定义定时任务调度线程池注入spring。默认线程池只有一个线程。

2.实现SchedulingConfigurer接口。多个任务编写多个类实现SchedulingConfigurer接口即可。

@Configuration public class ThreadPoolTaskSchedulerConfig {      //自定义定时任务调度线程池注入spring     @Bean     public ThreadPoolTaskScheduler threadPoolTaskScheduler() {         ThreadPoolTaskScheduler threadPoolTaskScheduler = new ThreadPoolTaskScheduler();         threadPoolTaskScheduler.setPoolSize(20);//定时任务数量需小于池大小。否则，可能会有定时任务等待执行         threadPoolTaskScheduler.setThreadNamePrefix("taskScheduler-");         threadPoolTaskScheduler.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());         threadPoolTaskScheduler.setWaitForTasksToCompleteOnShutdown(true);//调度器shutdown被调用时等待当前被调度的任务完成         threadPoolTaskScheduler.setAwaitTerminationSeconds(60);//等待时长         return threadPoolTaskScheduler;     }  }

@Component public class MySchedulingConfigurer implements SchedulingConfigurer {      @Override     public void configureTasks(ScheduledTaskRegistrar scheduledTaskRegistrar) {         scheduledTaskRegistrar.addTriggerTask(task(), trigger());     }      private Runnable task() {         return new Runnable() {             @Override             public void run() {                 //业务逻辑部分                 System.out.println("task1 ==== I am going:" + LocalDateTime.now());             }         };     }      private Trigger trigger() {         return new Trigger() {             @Override             public Date nextExecutionTime(TriggerContext triggerContext) {                 //每一次任务触发，都会执行这里的方法一次，重新获取下一次的执行时间。所以它是下下次才生效的，即不是实时生效                 String cron = "0/10 * * * * ?";//10秒执行一次,动态注入：这里改为从数据库获取表达式就可以了                 CronTrigger cronTrigger = new CronTrigger(cron);                 Date date = cronTrigger.nextExecutionTime(triggerContext);                 return date;             }         };     }  }

以上spring task动态定时任务缺点很明显，时间修改后不能马上生效，要等到下次执行加载Trigger后更新cron，下下次才会生效，所以想要即时生效就得用Quartz了！可参考：https://blog.csdn.net/yzh_1346983557/article/details/103990044