前言
学过定时工作，然而我忘了，忘得一尘不染，胆怯，始终听他人说：
你写一个定时工作就好了。
写个定时工作让他去爬取就行了。
我不会，所以当初得补回来了，欠下的究竟要还的，/(ㄒoㄒ)/~~
定时工作是什么？
大家都用过闹钟，闹钟能够说是一种定时工作。
比方咱们设定了周一到周五早上7点半的工夫响铃，那么闹钟就会在周一到周五的早上7点半进行响铃，这种就是定时的工作。工夫定在 周一到周五的早上7点半 ，工作就是 响铃。
那么，在 Java 中，如何实现这样的性能呢？即如何实现定时工作呢？
定时工作的有哪些是实现形式？
阐明：@Slf4j 注解来源于 Lombok ，须要引入 Lombok 依赖
纯手写单线程循环
单线程，写一个死循环，通过线程的睡眠（期待）实现定时工作：
@Slf4jpublic class ThreadTaskDemo { public static void main(String[] args) { timer1(); } public static void timer1() { new Thread(() -> { while (true) { log.info("以后工夫 {}", LocalDateTime.now()); try { // 每个1秒执行一次 Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } }).start(); }}控制台输入：
14:02:35.893 [Thread-0] INFO cn.god23bin.demo.timer.ThreadTaskDemo - 以后工夫 2022-10-25T14:02:35.89214:02:36.904 [Thread-0] INFO cn.god23bin.demo.timer.ThreadTaskDemo - 以后工夫 2022-10-25T14:02:36.90414:02:37.907 [Thread-0] INFO cn.god23bin.demo.timer.ThreadTaskDemo - 以后工夫 2022-10-25T14:02:37.907能够看到每秒执行一次，胜利实现了定时工作。
Timer 和它的小伙伴
在 java.util 包下，有这么 3 个货色，别离是 Timer 类、TimerTask 接口、TimerThread 类，这 3 个货色就能够帮咱们实现定时工作。
Timer 有这么 2 个办法（当然不止这两个，还有 4 个相干的）：
// 提早delay秒后执行task工作public void schedule(TimerTask task, long delay);// 提早delay秒后，以period间隔时间执行task工作public void schedule(TimerTask task, long delay, long period);TimerTask 有个 run() 形象办法，那咱们能够实现这个形象办法作为咱们的工作逻辑，因为 TimerTask 是接口，须要一个类实现它，那咱们上面就用匿名外部类的形式来实现这个接口。代码如下：
@Slf4jpublic class TimerDemo { public static void main(String[] args) { timer1(); } public static void timer1() { // 单线程 Timer timer = new Timer(); log.info("1秒后执行工作A，A实现后，期待1秒开始定时执行工作B，以后工夫 {}", LocalDateTime.now()); // 1秒后执行 timer.schedule(new TimerTask() { @Override public void run() { log.info("工作A 以后工夫 {}", LocalDateTime.now()); } }, 1000); // 这里 1000，就是代表提早 1000 毫秒后再执行 // 每隔2秒执行一次这个工作 timer.schedule(new TimerTask() { @Override public void run() { log.info("定时工作B 以后工夫 {}", LocalDateTime.now()); } }, 1000, 2000); // 1000 同理，2000 即执行完本次工作后，隔 2000 毫秒后再一次执行，达到定时工作的成果 }}控制台输入：
14:09:37.416 [main] INFO cn.god23bin.demo.timer.TimerDemo - 1秒后执行工作A，A实现后，期待1秒开始定时执行工作B，以后工夫 2022-10-25T14:09:37.41514:09:38.428 [Timer-0] INFO cn.god23bin.demo.timer.TimerDemo - 工作A 以后工夫 2022-10-25T14:09:38.42814:09:38.428 [Timer-0] INFO cn.god23bin.demo.timer.TimerDemo - 定时工作B 以后工夫 2022-10-25T14:09:38.42814:09:40.443 [Timer-0] INFO cn.god23bin.demo.timer.TimerDemo - 定时工作B 以后工夫 2022-10-25T14:09:40.44314:09:42.457 [Timer-0] INFO cn.god23bin.demo.timer.TimerDemo - 定时工作B 以后工夫 2022-10-25T14:09:42.457从控制台输入的工夫能够看到，工作 A 是只执行了一次，因为咱们没有传递 period 参数给 schedule () 办法。而工作 B 是一个定时工作，因为传递了 period 参数，period 参数为 2000，即 2000 毫秒。
所以，工作 B 会每隔 2 秒执行一次。到这里，咱们通过 Timer 实现了定时工作。上面看看基于多线程的 ScheduledExecutorService 接口。
ScheduledExecutorService
ScheduledExecutorService 接口位于 java.util.concurrent 包中，是继承 ExecutorService 接口的。
这个接口有 4 个形象办法（先理解一下）：
public ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit);public <V> ScheduledFuture<V> schedule(Callable<V> callable, long delay, TimeUnit unit);public ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit);public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit);从下面的形象办法能够看到，第一个参数是 Runnable 接口或 Callable 接口，这里就是写工作逻辑的，前面的 delay 也和之前的意思一样，提早多少工夫才开始执行这个定时工作，unit 次要是指定 long 参数的工夫单位。period 也是一样的意思，距离多少秒（周期）才执行下一次的工作。
ExecutorService 接口表述了异步执行的机制，并且能够让工作在后盾执行。ExecutorService 接口的实现类有咱们晓得的 ThreadPoolExecutor （不晓得的话，当初就晓得啦）。根本应用
那咱们如何获取 ScheduledExecutorService 的实现类？如何应用它实现定时工作？
能够通过 Executors.newSingleThreadScheduledExecutor() 获取其实现类，而后调用 schedule() 办法实现定时工作。
当初先看一下，如何应用：
@Slf4jpublic class ScheduledExecutorServiceDemo { public static void main(String[] args) throws ExecutionException, InterruptedException { testScheduledExecutorService(); } public static void testScheduledExecutorService() throws ExecutionException, InterruptedException { ScheduledExecutorService scheduledExecutorService = Executors.newSingleThreadScheduledExecutor(); log.info("2秒后开始执行工作，此刻工夫---{}", LocalDateTime.now()); ScheduledFuture<?> future = scheduledExecutorService.schedule(() -> { log.info("工作开始---{}", LocalDateTime.now()); try { Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } log.info("工作完结---{}", LocalDateTime.now()); return "ok"; }, 2000, TimeUnit.MILLISECONDS); // 提早 2 秒后执行 log.info("工作执行后 future {}, 工夫 {}", future.get(), LocalDateTime.now()); }}控制台输入：
14:15:44.510 [main] INFO cn.god23bin.demo.timer.ScheduledExecutorServiceDemo - 2秒后开始执行工作，此刻工夫---2022-10-25T14:15:44.50914:15:46.524 [pool-1-thread-1] INFO cn.god23bin.demo.timer.ScheduledExecutorServiceDemo - 工作开始---2022-10-25T14:15:46.52414:15:48.537 [pool-1-thread-1] INFO cn.god23bin.demo.timer.ScheduledExecutorServiceDemo - 工作完结---2022-10-25T14:15:48.53714:15:48.538 [main] INFO cn.god23bin.demo.timer.ScheduledExecutorServiceDemo - 工作执行后 future ok, 工夫 2022-10-25T14:15:48.538很显著，这里不是一个定时工作，因为只执行了一次就完结了，所以咱们须要调用两外两个来实现，别离是 scheduleAtFixedRate() 办法和 scheduleWithFixedDelay() 办法。
固定频率触发定时工作
scheduleAtFixedRate() 办法，能够固定多久就触发一次工作。上面咱们写一个提早 2 秒后开始执行工作，通过 5 秒后再执行下一次的工作的代码：
@Slf4jpublic class ScheduledExecutorServiceDemo { public static void main(String[] args) throws ExecutionException, InterruptedException { testFixedRate(); } public static void testFixedRate() { ScheduledExecutorService scheduledExecutorService = Executors.newSingleThreadScheduledExecutor(); log.info("2秒后开始执行工作，此刻工夫---{}", LocalDateTime.now()); // 固定频率（每隔5秒）开始执行一个工作 scheduledExecutorService.scheduleAtFixedRate(() -> { log.info("工作开始---{}", LocalDateTime.now()); try { Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } log.info("工作完结---{}", LocalDateTime.now()); }, 2000, 5000, TimeUnit.MILLISECONDS); }}通过 Thread.sleep(2000) 模仿工作执行了 2 秒的工夫，控制台输入如下：
14:17:15.081 [main] INFO cn.god23bin.demo.timer.ScheduledExecutorServiceDemo - 2秒后开始执行工作，此刻工夫---2022-10-25T14:17:15.07914:17:17.094 [pool-1-thread-1] INFO cn.god23bin.demo.timer.ScheduledExecutorServiceDemo - 工作开始---2022-10-25T14:17:17.09414:17:19.109 [pool-1-thread-1] INFO cn.god23bin.demo.timer.ScheduledExecutorServiceDemo - 工作完结---2022-10-25T14:17:19.10914:17:22.094 [pool-1-thread-1] INFO cn.god23bin.demo.timer.ScheduledExecutorServiceDemo - 工作开始---2022-10-25T14:17:22.09414:17:24.106 [pool-1-thread-1] INFO cn.god23bin.demo.timer.ScheduledExecutorServiceDemo - 工作完结---2022-10-25T14:17:24.10614:17:27.090 [pool-1-thread-1] INFO cn.god23bin.demo.timer.ScheduledExecutorServiceDemo - 工作开始---2022-10-25T14:17:27.09014:17:29.099 [pool-1-thread-1] INFO cn.god23bin.demo.timer.ScheduledExecutorServiceDemo - 工作完结---2022-10-25T14:17:29.099能够看到，第一次执行的工夫是 14:17:17 ，即第 17 秒，下一次执行的工夫是 14:17:22 ，即第 22 秒，这个过程通过了 5 秒钟，这就是 scheduleAtFixedRate() 办法的成果。
固定提早触发定时工作
scheduleWithFixedDelay() 办法，能够固定工作实现后提早多久才执行下一次工作。上面咱们写一个提早 1 秒后开始执行定时工作，当工作实现后，提早 4 秒再执行下一次工作。代码如下：
@Slf4jpublic class ScheduledExecutorServiceDemo { public static void main(String[] args) throws ExecutionException, InterruptedException { testFixedDelay(); } public static void testFixedDelay() { ScheduledExecutorService scheduledExecutorService = Executors.newSingleThreadScheduledExecutor(); log.info("1秒后开始执行工作，此刻工夫---{}", LocalDateTime.now()); // 工作实现后距离4秒开始执行下一次工作 scheduledExecutorService.scheduleWithFixedDelay(() -> { log.info("工作开始---{}", LocalDateTime.now()); try { Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } log.info("工作完结---{}", LocalDateTime.now()); }, 1000, 4000, TimeUnit.MILLISECONDS); }}通过 Thread.sleep(2000) 模仿工作执行了 2 秒的工夫，控制台输入如下：
14:20:31.352 [main] INFO cn.god23bin.demo.timer.ScheduledExecutorServiceDemo - 1秒后开始执行工作，此刻工夫---2022-10-25T14:20:31.35114:20:32.370 [pool-1-thread-1] INFO cn.god23bin.demo.timer.ScheduledExecutorServiceDemo - 工作开始---2022-10-25T14:20:32.37014:20:34.371 [pool-1-thread-1] INFO cn.god23bin.demo.timer.ScheduledExecutorServiceDemo - 工作完结---2022-10-25T14:20:34.37114:20:38.379 [pool-1-thread-1] INFO cn.god23bin.demo.timer.ScheduledExecutorServiceDemo - 工作开始---2022-10-25T14:20:38.37914:20:40.381 [pool-1-thread-1] INFO cn.god23bin.demo.timer.ScheduledExecutorServiceDemo - 工作完结---2022-10-25T14:20:40.381能够看到，第一次工作完结的工夫是 14:20:34 ，即第 34 秒，下一次执行的工夫是 14:17:38 ，即第 38 秒，这个过程通过了 4 秒钟，这就是 scheduleWithFixedDelay() 办法的成果。
以上就是 ScheduledExecutorService 实现的定时工作，接下来看看 Spring 提供的。
Spring 提供的定时工作
Spring 提供了 @EnableScheduling 和 @Scheduled 这两个注解来实现定时工作。
咱们能够编写一个类，加上 @Component 让 Spring 来治理这个 Bean（当然，也能够用 @Configuration 注解），加上 @EnableScheduling 表明该 Bean 具备可开启定时工作的性能。
在这个一般的类中编写办法，你能够让你写的办法成为一个定时工作，只需在办法上加上 @Scheduled 注解就能够了，就是这么简略！
还有一个就是 cron 表达式 须要学习，这个表达式能够表明这个办法何时执行。
上面是一个简略的定时工作：
@Slf4j@Component@EnableSchedulingpublic class TaskDemo { @Scheduled(cron = "*/1 * * * * ?") public void printTime() throws InterruptedException { log.info("此刻工夫 {}", LocalDateTime.now()); } }cron 表达式有 6 位，是必须的，从左到右别离示意：秒、分、时、日、月、周。
当然也有可能是 7 位，那么最初一位就是年（个别省略不写）：秒、分、时、日、月、周、年。
取值阐明：失常意识，秒分都是 0 - 59，时则是 0 - 23，日则是 1 - 31，月则是 1-12，周则是 1 - 7。年则只有 1970 - 2099
每一位都能够用数字示意，当然还能够用一些特殊字符示意，比方下面呈现的 */1 * * * * ? ，第 1 位的 */1 示意任意秒每隔1秒，第 2 位的 * 示意任意分钟，以此类推。
具体可参考这里：简书-Cron表达式的具体用法
Cron 生成工具：https://cron.qqe2.com/
下面的代码运行之后，控制台输入：
2022-10-25 14:26:22.013 INFO 18304 --- [ scheduling-1] cn.god23bin.demo.task.TaskDemo : 此刻工夫 2022-10-25T14:26:22.0132022-10-25 14:26:23.010 INFO 18304 --- [ scheduling-1] cn.god23bin.demo.task.TaskDemo : 此刻工夫 2022-10-25T14:26:23.0102022-10-25 14:26:24.011 INFO 18304 --- [ scheduling-1] cn.god23bin.demo.task.TaskDemo : 此刻工夫 2022-10-25T14:26:24.0112022-10-25 14:26:25.011 INFO 18304 --- [ scheduling-1] cn.god23bin.demo.task.TaskDemo : 此刻工夫 2022-10-25T14:26:25.011能够看到，的确是每隔 1 秒执行一次 printTime() 这个定时工作。
@Scheduled 的另外两个属性
@Scheduled 注解除了 cron 这个属性外，还有 fixedRate 属性和 fixedDelay 属性，同理，就是固定频率触发定时工作和固定提早触发定时工作
fixedRate
@Slf4j@Component@EnableSchedulingpublic class TaskDemo { /** * 当前任务执行到下一个工作开始的工夫（固定频率开始执行一个工作，每5秒执行），都是单线程解决的 **/ @Scheduled(fixedRate = 5000) public void printTime1() throws InterruptedException { log.info("工作开始------- {}", LocalDateTime.now()); Thread.sleep(1000); log.info("工作实现------- {}", LocalDateTime.now()); } }控制台输入：
2022-10-25 14:54:04.824 INFO 23520 --- [ scheduling-1] cn.god23bin.demo.task.TaskDemo : 工作开始------- 2022-10-25T14:54:04.8242022-10-25 14:54:05.833 INFO 23520 --- [ scheduling-1] cn.god23bin.demo.task.TaskDemo : 工作实现------- 2022-10-25T14:54:05.8332022-10-25 14:54:09.834 INFO 23520 --- [ scheduling-1] cn.god23bin.demo.task.TaskDemo : 工作开始------- 2022-10-25T14:54:09.8342022-10-25 14:54:10.843 INFO 23520 --- [ scheduling-1] cn.god23bin.demo.task.TaskDemo : 工作实现------- 2022-10-25T14:54:10.843当然，如果工作的解决逻辑超过了固定的频率工夫，比方咱们批改下 Thread.sleep(1000) ，模仿成 6 秒，即 Thread.sleep(6000)，那么输入如下：
2022-10-25 14:57:04.212 INFO 9324 --- [ scheduling-1] cn.god23bin.demo.task.TaskDemo : 工作开始------- 2022-10-25T14:57:04.2122022-10-25 14:57:10.227 INFO 9324 --- [ scheduling-1] cn.god23bin.demo.task.TaskDemo : 工作实现------- 2022-10-25T14:57:10.2272022-10-25 14:57:10.227 INFO 9324 --- [ scheduling-1] cn.god23bin.demo.task.TaskDemo : 工作开始------- 2022-10-25T14:57:10.2272022-10-25 14:57:16.241 INFO 9324 --- [ scheduling-1] cn.god23bin.demo.task.TaskDemo : 工作实现------- 2022-10-25T14:57:16.2412022-10-25 14:57:16.242 INFO 9324 --- [ scheduling-1] cn.god23bin.demo.task.TaskDemo : 工作开始------- 2022-10-25T14:57:16.2422022-10-25 14:57:22.243 INFO 9324 --- [ scheduling-1] cn.god23bin.demo.task.TaskDemo : 工作实现------- 2022-10-25T14:57:22.2432022-10-25 14:57:22.243 INFO 9324 --- [ scheduling-1] cn.god23bin.demo.task.TaskDemo : 工作开始------- 2022-10-25T14:57:22.243能够发现，当前任务一实现就会立即执行下一次工作，这就是当工作的解决逻辑超过了固定的频率工夫会呈现的状况。
fixedDelay
@Slf4j@Component@EnableSchedulingpublic class TaskDemo { /** * 执行实现后距离2秒执行下一次 **/ @Scheduled(fixedDelay = 2000) public void printTime2() throws InterruptedException { log.info("工作开始------- {}", LocalDateTime.now()); Thread.sleep(4000); log.info("工作实现------- {}", LocalDateTime.now()); } }控制台输入：
2022-10-25 14:55:50.973 INFO 22128 --- [ scheduling-1] cn.god23bin.demo.task.TaskDemo : 工作开始------- 2022-10-25T14:55:50.9732022-10-25 14:55:54.977 INFO 22128 --- [ scheduling-1] cn.god23bin.demo.task.TaskDemo : 工作实现------- 2022-10-25T14:55:54.9772022-10-25 14:55:56.987 INFO 22128 --- [ scheduling-1] cn.god23bin.demo.task.TaskDemo : 工作开始------- 2022-10-25T14:55:56.9872022-10-25 14:56:01.001 INFO 22128 --- [ scheduling-1] cn.god23bin.demo.task.TaskDemo : 工作实现------- 2022-10-25T14:56:01.0012022-10-25 14:56:03.012 INFO 22128 --- [ scheduling-1] cn.god23bin.demo.task.TaskDemo : 工作开始------- 2022-10-25T14:56:03.012多个定时工作的执行
同步
如果咱们写多个定时工作，那么它们只会同步执行，如下：
@Slf4j@Component@EnableSchedulingpublic class TaskDemo { @Scheduled(fixedRate = 2000) public void printTime3() throws InterruptedException { log.info("工作A开始------- {}", LocalDateTime.now()); Thread.sleep(2000); log.info("工作A实现------- {}", LocalDateTime.now()); } @Scheduled(fixedDelay = 2000) public void printTime4() throws InterruptedException { log.info("工作B开始------- {}", LocalDateTime.now()); Thread.sleep(2000); log.info("工作B实现------- {}", LocalDateTime.now()); } }控制台输入：
2022-10-25 14:59:14.279 INFO 21588 --- [ scheduling-1] cn.god23bin.demo.task.TaskDemo : 工作A开始------- 2022-10-25T14:59:14.2792022-10-25 14:59:16.283 INFO 21588 --- [ scheduling-1] cn.god23bin.demo.task.TaskDemo : 工作A实现------- 2022-10-25T14:59:16.2832022-10-25 14:59:16.283 INFO 21588 --- [ scheduling-1] cn.god23bin.demo.task.TaskDemo : 工作B开始------- 2022-10-25T14:59:16.2832022-10-25 14:59:18.288 INFO 21588 --- [ scheduling-1] cn.god23bin.demo.task.TaskDemo : 工作B实现------- 2022-10-25T14:59:18.2882022-10-25 14:59:18.288 INFO 21588 --- [ scheduling-1] cn.god23bin.demo.task.TaskDemo : 工作A开始------- 2022-10-25T14:59:18.2882022-10-25 14:59:20.301 INFO 21588 --- [ scheduling-1] cn.god23bin.demo.task.TaskDemo : 工作A实现------- 2022-10-25T14:59:20.3012022-10-25 14:59:20.301 INFO 21588 --- [ scheduling-1] cn.god23bin.demo.task.TaskDemo : 工作A开始------- 2022-10-25T14:59:20.3012022-10-25 14:59:22.307 INFO 21588 --- [ scheduling-1] cn.god23bin.demo.task.TaskDemo : 工作A实现------- 2022-10-25T14:59:22.3072022-10-25 14:59:22.307 INFO 21588 --- [ scheduling-1] cn.god23bin.demo.task.TaskDemo : 工作A开始------- 2022-10-25T14:59:22.3072022-10-25 14:59:24.323 INFO 21588 --- [ scheduling-1] cn.god23bin.demo.task.TaskDemo : 工作A实现------- 2022-10-25T14:59:24.3232022-10-25 14:59:24.323 INFO 21588 --- [ scheduling-1] cn.god23bin.demo.task.TaskDemo : 工作B开始------- 2022-10-25T14:59:24.3232022-10-25 14:59:26.337 INFO 21588 --- [ scheduling-1] cn.god23bin.demo.task.TaskDemo : 工作B实现------- 2022-10-25T14:59:26.337能够看到，只有某一个工作实现后，下一个工作才会执行。
如果想要异步，如何异步呢？
异步
很简略，应用 @EnableAsync 和 @Async 这两个注解就能够了，如下：
@Slf4j@Component@EnableScheduling@EnableAsyncpublic class TaskDemo { @Async @Scheduled(fixedRate = 2000) public void printTime3() throws InterruptedException { log.info("工作A开始------- {}", LocalDateTime.now()); Thread.sleep(2000); log.info("工作A实现------- {}", LocalDateTime.now()); } @Async @Scheduled(fixedDelay = 2000) public void printTime4() throws InterruptedException { log.info("工作B开始------- {}", LocalDateTime.now()); Thread.sleep(2000); log.info("工作B实现------- {}", LocalDateTime.now()); } }控制台输入：
2022-10-25 15:04:05.833 INFO 15604 --- [ task-1] cn.god23bin.demo.task.TaskDemo : 工作A开始------- 2022-10-25T15:04:05.8332022-10-25 15:04:05.833 INFO 15604 --- [ task-2] cn.god23bin.demo.task.TaskDemo : 工作B开始------- 2022-10-25T15:04:05.8332022-10-25 15:04:07.833 INFO 15604 --- [ task-4] cn.god23bin.demo.task.TaskDemo : 工作B开始------- 2022-10-25T15:04:07.8332022-10-25 15:04:07.833 INFO 15604 --- [ task-3] cn.god23bin.demo.task.TaskDemo : 工作A开始------- 2022-10-25T15:04:07.8332022-10-25 15:04:07.848 INFO 15604 --- [ task-2] cn.god23bin.demo.task.TaskDemo : 工作B实现------- 2022-10-25T15:04:07.8482022-10-25 15:04:07.848 INFO 15604 --- [ task-1] cn.god23bin.demo.task.TaskDemo : 工作A实现------- 2022-10-25T15:04:07.8482022-10-25 15:04:09.833 INFO 15604 --- [ task-5] cn.god23bin.demo.task.TaskDemo : 工作A开始------- 2022-10-25T15:04:09.8332022-10-25 15:04:09.843 INFO 15604 --- [ task-4] cn.god23bin.demo.task.TaskDemo : 工作B实现------- 2022-10-25T15:04:09.8432022-10-25 15:04:09.843 INFO 15604 --- [ task-3] cn.god23bin.demo.task.TaskDemo : 工作A实现------- 2022-10-25T15:04:09.8432022-10-25 15:04:09.844 INFO 15604 --- [ task-6] cn.god23bin.demo.task.TaskDemo : 工作B开始------- 2022-10-25T15:04:09.8432022-10-25 15:04:11.830 INFO 15604 --- [ task-7] cn.god23bin.demo.task.TaskDemo : 工作A开始------- 2022-10-25T15:04:11.8302022-10-25 15:04:11.845 INFO 15604 --- [ task-6] cn.god23bin.demo.task.TaskDemo : 工作B实现------- 2022-10-25T15:04:11.8452022-10-25 15:04:11.845 INFO 15604 --- [ task-5] cn.god23bin.demo.task.TaskDemo : 工作A实现------- 2022-10-25T15:04:11.845总结
首先讲了下定时工作是什么？接着讲了有哪些实现形式？对这些形式进行介绍。
次要的定时工作能够通过以下的形式实现：
- 纯手写单线程死循环，配合线程的期待机制的形式（不举荐，麻烦，问题多多）
- 应用 JDK 提供的 Timer 配合 TimerTask 的形式（不举荐，单线程）
- 应用 JDK 提供的多线程的 ScheduledExecutorService 的形式（可代替 Timer，多线程的）
- 应用 Spring 提供的定时工作的形式（举荐，更加不便，可异步）
当然，除了这些形式，还能够应用定时工作框架，比方 Quartz、XXL-JOB、Elastic-Job 等等。
最初的最初
由自己程度所限，不免有谬误以及不足之处， 屏幕前的靓仔靓女们 如有发现，恳请指出！
最初，谢谢你看到这里，谢谢你认真对待我的致力，心愿这篇博客对你有所帮忙！
你轻轻地点了个赞，那将在我的心里世界削减一颗亮堂而夺目的星！