Java实现定时任务的方法详解

2024-09-28 16:47:56

前言

学过定时任务，但是我忘了，忘得一干二净，害怕，一直听别人说：

你写一个定时任务就好了。

写个定时任务让他去爬取就行了。

我不会，所以现在得补回来了，欠下的终究要还的，/(ㄒ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

可以看到每秒执行一次，成功实现了定时任务。

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 是接口，需要一个类实现它，那我们下面就用匿名内部类的方式来实现这个接口。代码如下：

@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

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 提供的定时任务

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 的另外两个属性

@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实现定时任务的方法详解的文章就介绍到这了,更多相关Java定时任务内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！

Java实现定时任务

本文实例为大家分享了Java实现定时任务的具体代码,供大家参考,具体内容如下 1 使用java.util.Timer 这种方式的定时任务主要用到两个类,Timer 和 TimerTask,使用起来比较简单.其中 Timer 负责设定 TimerTask 的起始与间隔执行时间. TimerTask是一个抽象类,new的时候实现自己的 run 方法,然后将其丢给 Timer 去执行即可. 代码示例: import java.time.LocalDateTime; import java.util.T
java实现周期性执行(定时任务)

最近是遇到一个设备在线离线的判定问题,设计是每个多长时间(常规的定时任务)检测一次设备是否在前,当检测到里离线时,我们不能立马判断为离线,而是要在重试多测几次,只要一次成功就返回判定为在线,多次都不成功侧是离线,我这里相当了用ScheduledThreadPoolExecutor来实现,如有不足还请提出.如下: ScheduledThreadPoolExecutor的介绍: ScheduledThreadPoolExecutor,它可另行安排在给定的延迟后运行命令,或者定期执行命令.需要多个辅助
Java项目实现定时任务的三种方法

目录 1 使用java.util.Timer 2 使用ScheduledExecutorService 3 使用Spring Task 总结 1 使用java.util.Timer 这种方式的定时任务主要用到两个类,Timer 和 TimerTask,使用起来比较简单.其中 Timer 负责设定 TimerTask 的起始与间隔执行时间. TimerTask是一个抽象类,new的时候实现自己的 run 方法,然后将其丢给 Timer 去执行即可. 代码示例: import java.time.L
Java定时任务原理详解

目录序章一.Scheduled 1.1 使用方法 1.2 源码分析二.QUARTZ 2.1 使用方法 2.2 源码分析序章定时任务实现方式当下,java编码过程中,实现定时任务的方式主要以以下两种为主 spring框架的@Scheduled quzrtz框架网络上关于这两种框架的实践和配置相关的教程很多,这里不再赘述. 本文主要就二者的框架原理实现做一个入门引导,为了解深层实现细节做一定的铺垫. 本文源码版本 spring-context-3.2.18.RELEASE.jar qu
Java实现定时任务最简单的3种方法

目录一.Timer 二.ScheduledExecutorService 三.Spring Task 1.开启定时任务 2.添加定时任务 Cron 表达式知识扩展:分布式定时任务 1.ZSet 实现方式 2.键空间通知总结一.Timer Timer是JAVA自带的定时任务类,实现如下: public class MyTimerTask { public static void main(String[] args) { // 定义一个任务 TimerTask timerTask = ne
Java实现定时任务的方法详解

目录前言定时任务是什么定时任务的有哪些是实现方式纯手写单线程循环 Timer 和它的小伙伴 ScheduledExecutorService Spring 提供的定时任务总结前言学过定时任务,但是我忘了,忘得一干二净,害怕,一直听别人说: 你写一个定时任务就好了. 写个定时任务让他去爬取就行了. 我不会,所以现在得补回来了,欠下的终究要还的,/(ㄒoㄒ)/~~ 定时任务是什么大家都用过闹钟,闹钟可以说是一种定时任务. 比如我们设定了周一到周五早上7点半的时间响铃,那么闹钟就会在周
SpringBoot设置动态定时任务的方法详解

之前写过文章记录怎么在SpringBoot项目中简单使用定时任务,不过由于要借助cron表达式且都提前定义好放在配置文件里,不能在项目运行中动态修改任务执行时间,实在不太灵活. 经过网上搜索学习后,特此记录如何在SpringBoot项目中实现动态定时任务. 因为只是一个demo,所以只引入了需要的依赖: <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <ar
Java枚举的使用方法详解

Java枚举的使用方法详解前言你代码中的flag和status,都应该用枚举来替代很多人都说,枚举在实际开发中很少用到,甚至就没用到.因为,他们的代码往往是这样子的: public class Constant { /* * 以下几个变量表示英雄的状态 */ public final static int STATUS_WALKING = 0;//走 public final static int STATUS_RUNNINGING = 1;//跑 public final stati
Linux crontab定时任务配置方法(详解)

CRONTAB概念/介绍 crontab命令用于设置周期性被执行的指令.该命令从标准输入设备读取指令,并将其存放于"crontab"文件中,以供之后读取和执行. cron 系统调度进程. 可以使用它在每天的非高峰负荷时间段运行作业,或在一周或一月中的不同时段运行.cron是系统主要的调度进程,可以在无需人工干预的情况下运行作业.crontab命令允许用户提交.编辑或删除相应的作业.每一个用户都可以有一个crontab文件来保存调度信息.系统管理员可以通过cron.deny 和 cron
java Future 接口使用方法详解

java Future 接口使用方法详解在Java中,如果需要设定代码执行的最长时间,即超时,可以用Java线程池ExecutorService类配合Future接口来实现. Future接口是Java标准API的一部分,在java.util.concurrent包中.Future接口是Java线程Future模式的实现,可以来进行异步计算. Future模式可以这样来描述:我有一个任务,提交给了Future,Future替我完成这个任务.期间我自己可以去做任何想做的事情.一段时间之后,我就便
Java String对象使用方法详解

Java String对象使用方法详解先来看一个例子,代码如下: public class Test { public static void main(String[] args) { String str = "abc"; String str1 = "abc"; String str2 = new String("abc"); System.out.println(str == str1); System.out.println(str1
navicat创建MySql定时任务的方法详解

navicat创建MySql 定时任务详解事件(event)是MySQL在相应的时刻调用的过程式数据库对象.一个事件可调用一次,也可周期性的启动,它由一个特定的线程来管理的,也就是所谓的"事件调度器".事件和触发器类似,都是在某些事情发生的时候启动.当数据库上启动一条语句的时候,触发器就启动了,而事件是根据调度事件来启动的.由于他们彼此相似,所以事件也称为临时性触发器.事件取代了原先只能由操作系统的计划任务来执行的工作,而且MySQL的事件调度器可以精确到每秒钟执行一个任务,而操作系
Java螺旋矩阵处理方法详解

题目描述: 给定一 m*n 的矩阵,请按照逆时针螺旋顺序,返回矩阵中所有元素. 示例: 思路: 这是一道典型的模拟问题: 我们可以分析一下,遍历前进轨迹: 向右 - > 向下 -> 向左 -> 向上 -> 向右 … 于是,我们可以在循环中模拟这样的前进轨迹,记录右,下,上左,四个边界,每次拐弯时更新边界值,再进行下一次拐弯,循环往复,直至结束.结束条件为左边界加一大于右边界,或者上边界加一大于下边界. 图解: 代码: class Solution { public List&l
java获取类名的方法详解

如果我们要获取当前运行的类名,怎么来获取? 在Class类中,有如下一个方法: 比如现在有一个类Demo7.java package pxx.test1; public class Demo7 { public static void main(String[] args) { Demo7 demo7 = new Demo7(); System.out.println(demo7.getClass().getName()); } } 运行结果: 上面就是直接这个对象调用了getClass()得到
Java文本编辑器实现方法详解

本文实例讲述了Java文本编辑器实现方法.分享给大家供大家参考,具体如下: 结构分析: 界面布局 : EditFrame main方法所在: EditText 打开功能实现: FileReadThread 保存跟能实现: save 实际运行效果: 附:完整代码实现一. EditFrame 包括一个菜单Menu 底部:日期时间代码附上: public class EditFrame extends JFrame { // TODO 自动生成的构造函数存根 boolean saveFlag

Java实现定时任务的方法详解

目录

前言

定时任务是什么

定时任务的有哪些是实现方式

纯手写单线程循环

Timer 和它的小伙伴

ScheduledExecutorService

Spring 提供的定时任务

总结

相关推荐

随机推荐