关于后端:我终于会写-Java-的定时任务了

学过定时工作，然而我忘了，忘得一尘不染，胆怯，始终听他人说：

你写一个定时工作就好了。

写个定时工作让他去爬取就行了。

我不会，所以当初得补回来了，欠下的究竟要还的，/(ㄒ o ㄒ)/~~

大家都用过闹钟，闹钟能够说是一种定时工作。

比方咱们设定了周一到周五早上 7 点半的工夫响铃，那么闹钟就会在周一到周五的早上 7 点半进行响铃，这种就是定时的工作。工夫定在 周一到周五的早上 7 点半 ，工作就是响铃。

那么，在 Java 中，如何实现这样的性能呢？即 如何实现定时工作呢？

阐明：@Slf4j 注解来源于 Lombok，须要引入 Lombok 依赖

单线程，写一个死循环，通过线程的睡眠（期待）实现定时工作：

@Slf4j
public 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.892
14:02:36.904 [Thread-0] INFO cn.god23bin.demo.timer.ThreadTaskDemo - 以后工夫 2022-10-25T14:02:36.904
14:02:37.907 [Thread-0] INFO cn.god23bin.demo.timer.ThreadTaskDemo - 以后工夫 2022-10-25T14:02:37.907

能够看到每秒执行一次，胜利实现了定时工作。

在 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 是接口，须要一个类实现它，那咱们上面就用 匿名外部类的形式 来实现这个接口。代码如下：

@Slf4j
public 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.415
14:09:38.428 [Timer-0] INFO cn.god23bin.demo.timer.TimerDemo - 工作 A 以后工夫 2022-10-25T14:09:38.428
14:09:38.428 [Timer-0] INFO cn.god23bin.demo.timer.TimerDemo - 定时工作 B 以后工夫 2022-10-25T14:09:38.428
14:09:40.443 [Timer-0] INFO cn.god23bin.demo.timer.TimerDemo - 定时工作 B 以后工夫 2022-10-25T14:09:40.443
14: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 接口位于 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() 办法实现定时工作。

当初先看一下，如何应用：

@Slf4j
public 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.509
14:15:46.524 [pool-1-thread-1] INFO cn.god23bin.demo.timer.ScheduledExecutorServiceDemo - 工作开始 ---2022-10-25T14:15:46.524
14:15:48.537 [pool-1-thread-1] INFO cn.god23bin.demo.timer.ScheduledExecutorServiceDemo - 工作完结 ---2022-10-25T14:15:48.537
14:15:48.538 [main] INFO cn.god23bin.demo.timer.ScheduledExecutorServiceDemo - 工作执行后 future ok, 工夫 2022-10-25T14:15:48.538

很显著，这里不是一个定时工作，因为只执行了一次就完结了，所以咱们须要调用两外两个来实现，别离是 scheduleAtFixedRate() 办法和 scheduleWithFixedDelay() 办法。

scheduleAtFixedRate() 办法，能够固定多久就触发一次工作。上面咱们写一个提早 2 秒后开始执行工作，通过 5 秒后再执行下一次的工作的代码：

@Slf4j
public 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.079
14:17:17.094 [pool-1-thread-1] INFO cn.god23bin.demo.timer.ScheduledExecutorServiceDemo - 工作开始 ---2022-10-25T14:17:17.094
14:17:19.109 [pool-1-thread-1] INFO cn.god23bin.demo.timer.ScheduledExecutorServiceDemo - 工作完结 ---2022-10-25T14:17:19.109
14:17:22.094 [pool-1-thread-1] INFO cn.god23bin.demo.timer.ScheduledExecutorServiceDemo - 工作开始 ---2022-10-25T14:17:22.094
14:17:24.106 [pool-1-thread-1] INFO cn.god23bin.demo.timer.ScheduledExecutorServiceDemo - 工作完结 ---2022-10-25T14:17:24.106
14:17:27.090 [pool-1-thread-1] INFO cn.god23bin.demo.timer.ScheduledExecutorServiceDemo - 工作开始 ---2022-10-25T14:17:27.090
14: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 秒再执行下一次工作。代码如下：

@Slf4j
public 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.351
14:20:32.370 [pool-1-thread-1] INFO cn.god23bin.demo.timer.ScheduledExecutorServiceDemo - 工作开始 ---2022-10-25T14:20:32.370
14:20:34.371 [pool-1-thread-1] INFO cn.god23bin.demo.timer.ScheduledExecutorServiceDemo - 工作完结 ---2022-10-25T14:20:34.371
14:20:38.379 [pool-1-thread-1] INFO cn.god23bin.demo.timer.ScheduledExecutorServiceDemo - 工作开始 ---2022-10-25T14:20:38.379
14: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 提供了 @EnableScheduling 和 @Scheduled 这两个注解来实现定时工作。

咱们能够编写一个类，加上 @Component 让 Spring 来治理这个 Bean（当然，也能够用 @Configuration 注解），加上 @EnableScheduling 表明该 Bean 具备可开启定时工作的性能。

在这个一般的类中编写办法，你能够让你写的办法成为一个定时工作，只需在办法上加上 @Scheduled 注解就能够了，就是这么简略！

还有一个就是 cron 表达式 须要学习，这个表达式能够表明这个办法 何时执行。

上面是一个简略的定时工作：

@Slf4j
@Component
@EnableScheduling
public 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.013
2022-10-25 14:26:23.010  INFO 18304 --- [scheduling-1] cn.god23bin.demo.task.TaskDemo           : 此刻工夫 2022-10-25T14:26:23.010
2022-10-25 14:26:24.011  INFO 18304 --- [scheduling-1] cn.god23bin.demo.task.TaskDemo           : 此刻工夫 2022-10-25T14:26:24.011
2022-10-25 14:26:25.011  INFO 18304 --- [scheduling-1] cn.god23bin.demo.task.TaskDemo           : 此刻工夫 2022-10-25T14:26:25.011

能够看到，的确是每隔 1 秒执行一次 printTime() 这个定时工作。

@Scheduled 注解除了 cron 这个属性外，还有 fixedRate 属性和 fixedDelay 属性，同理，就是 固定频率触发定时工作 和固定提早触发定时工作

fixedRate

@Slf4j
@Component
@EnableScheduling
public 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.824
2022-10-25 14:54:05.833  INFO 23520 --- [scheduling-1] cn.god23bin.demo.task.TaskDemo           : 工作实现 ------- 2022-10-25T14:54:05.833
2022-10-25 14:54:09.834  INFO 23520 --- [scheduling-1] cn.god23bin.demo.task.TaskDemo           : 工作开始 ------- 2022-10-25T14:54:09.834
2022-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.212
2022-10-25 14:57:10.227  INFO 9324 --- [scheduling-1] cn.god23bin.demo.task.TaskDemo           : 工作实现 ------- 2022-10-25T14:57:10.227
2022-10-25 14:57:10.227  INFO 9324 --- [scheduling-1] cn.god23bin.demo.task.TaskDemo           : 工作开始 ------- 2022-10-25T14:57:10.227
2022-10-25 14:57:16.241  INFO 9324 --- [scheduling-1] cn.god23bin.demo.task.TaskDemo           : 工作实现 ------- 2022-10-25T14:57:16.241
2022-10-25 14:57:16.242  INFO 9324 --- [scheduling-1] cn.god23bin.demo.task.TaskDemo           : 工作开始 ------- 2022-10-25T14:57:16.242
2022-10-25 14:57:22.243  INFO 9324 --- [scheduling-1] cn.god23bin.demo.task.TaskDemo           : 工作实现 ------- 2022-10-25T14:57:22.243
2022-10-25 14:57:22.243  INFO 9324 --- [scheduling-1] cn.god23bin.demo.task.TaskDemo           : 工作开始 ------- 2022-10-25T14:57:22.243

能够发现，当前任务一实现就会立即执行下一次工作，这就是当工作的解决逻辑超过了固定的频率工夫会呈现的状况。

fixedDelay

@Slf4j
@Component
@EnableScheduling
public 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.973
2022-10-25 14:55:54.977  INFO 22128 --- [scheduling-1] cn.god23bin.demo.task.TaskDemo           : 工作实现 ------- 2022-10-25T14:55:54.977
2022-10-25 14:55:56.987  INFO 22128 --- [scheduling-1] cn.god23bin.demo.task.TaskDemo           : 工作开始 ------- 2022-10-25T14:55:56.987
2022-10-25 14:56:01.001  INFO 22128 --- [scheduling-1] cn.god23bin.demo.task.TaskDemo           : 工作实现 ------- 2022-10-25T14:56:01.001
2022-10-25 14:56:03.012  INFO 22128 --- [scheduling-1] cn.god23bin.demo.task.TaskDemo           : 工作开始 ------- 2022-10-25T14:56:03.012

同步

如果咱们写多个定时工作，那么它们只会同步执行，如下：

@Slf4j
@Component
@EnableScheduling
public 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.279
2022-10-25 14:59:16.283  INFO 21588 --- [scheduling-1] cn.god23bin.demo.task.TaskDemo           : 工作 A 实现 ------- 2022-10-25T14:59:16.283
2022-10-25 14:59:16.283  INFO 21588 --- [scheduling-1] cn.god23bin.demo.task.TaskDemo           : 工作 B 开始 ------- 2022-10-25T14:59:16.283
2022-10-25 14:59:18.288  INFO 21588 --- [scheduling-1] cn.god23bin.demo.task.TaskDemo           : 工作 B 实现 ------- 2022-10-25T14:59:18.288
2022-10-25 14:59:18.288  INFO 21588 --- [scheduling-1] cn.god23bin.demo.task.TaskDemo           : 工作 A 开始 ------- 2022-10-25T14:59:18.288
2022-10-25 14:59:20.301  INFO 21588 --- [scheduling-1] cn.god23bin.demo.task.TaskDemo           : 工作 A 实现 ------- 2022-10-25T14:59:20.301
2022-10-25 14:59:20.301  INFO 21588 --- [scheduling-1] cn.god23bin.demo.task.TaskDemo           : 工作 A 开始 ------- 2022-10-25T14:59:20.301
2022-10-25 14:59:22.307  INFO 21588 --- [scheduling-1] cn.god23bin.demo.task.TaskDemo           : 工作 A 实现 ------- 2022-10-25T14:59:22.307
2022-10-25 14:59:22.307  INFO 21588 --- [scheduling-1] cn.god23bin.demo.task.TaskDemo           : 工作 A 开始 ------- 2022-10-25T14:59:22.307
2022-10-25 14:59:24.323  INFO 21588 --- [scheduling-1] cn.god23bin.demo.task.TaskDemo           : 工作 A 实现 ------- 2022-10-25T14:59:24.323
2022-10-25 14:59:24.323  INFO 21588 --- [scheduling-1] cn.god23bin.demo.task.TaskDemo           : 工作 B 开始 ------- 2022-10-25T14:59:24.323
2022-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
@EnableAsync
public 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.833
2022-10-25 15:04:05.833  INFO 15604 --- [task-2] cn.god23bin.demo.task.TaskDemo           : 工作 B 开始 ------- 2022-10-25T15:04:05.833
2022-10-25 15:04:07.833  INFO 15604 --- [task-4] cn.god23bin.demo.task.TaskDemo           : 工作 B 开始 ------- 2022-10-25T15:04:07.833
2022-10-25 15:04:07.833  INFO 15604 --- [task-3] cn.god23bin.demo.task.TaskDemo           : 工作 A 开始 ------- 2022-10-25T15:04:07.833
2022-10-25 15:04:07.848  INFO 15604 --- [task-2] cn.god23bin.demo.task.TaskDemo           : 工作 B 实现 ------- 2022-10-25T15:04:07.848
2022-10-25 15:04:07.848  INFO 15604 --- [task-1] cn.god23bin.demo.task.TaskDemo           : 工作 A 实现 ------- 2022-10-25T15:04:07.848
2022-10-25 15:04:09.833  INFO 15604 --- [task-5] cn.god23bin.demo.task.TaskDemo           : 工作 A 开始 ------- 2022-10-25T15:04:09.833
2022-10-25 15:04:09.843  INFO 15604 --- [task-4] cn.god23bin.demo.task.TaskDemo           : 工作 B 实现 ------- 2022-10-25T15:04:09.843
2022-10-25 15:04:09.843  INFO 15604 --- [task-3] cn.god23bin.demo.task.TaskDemo           : 工作 A 实现 ------- 2022-10-25T15:04:09.843
2022-10-25 15:04:09.844  INFO 15604 --- [task-6] cn.god23bin.demo.task.TaskDemo           : 工作 B 开始 ------- 2022-10-25T15:04:09.843
2022-10-25 15:04:11.830  INFO 15604 --- [task-7] cn.god23bin.demo.task.TaskDemo           : 工作 A 开始 ------- 2022-10-25T15:04:11.830
2022-10-25 15:04:11.845  INFO 15604 --- [task-6] cn.god23bin.demo.task.TaskDemo           : 工作 B 实现 ------- 2022-10-25T15:04:11.845
2022-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 等等。

由自己程度所限，不免有谬误以及不足之处，屏幕前的靓仔靓女们 如有发现，恳请指出！

最初，谢谢你看到这里，谢谢你认真对待我的致力，心愿这篇博客对你有所帮忙！

你轻轻地点了个赞，那将在我的心里世界削减一颗亮堂而夺目的星！

关于后端:我终于会写-Java-的定时任务了

前言

定时工作是什么？

定时工作的有哪些是实现形式？

纯手写单线程循环

Timer 和它的小伙伴

ScheduledExecutorService

根本应用

固定频率触发定时工作

固定提早触发定时工作

Spring 提供的定时工作

@Scheduled 的另外两个属性

fixedRate

fixedDelay

多个定时工作的执行

同步

异步

总结

最初的最初

Just My Socks（注册教程内含优惠码）

关于后端:我终于会写-Java-的定时任务了

前言

定时工作是什么？

定时工作的有哪些是实现形式？

纯手写单线程循环

Timer 和它的小伙伴

ScheduledExecutorService

根本应用

固定频率触发定时工作

固定提早触发定时工作

Spring 提供的定时工作

@Scheduled 的另外两个属性

fixedRate

fixedDelay

多个定时工作的执行

同步

异步

总结

最初的最初

Just My Socks（注册教程 内含优惠码）

Just My Socks（注册教程内含优惠码）