Java 中常用的定時調(diào)度框架有以下幾種：

• Timer：Java 標準庫中提供的一個定時調(diào)度工具，可以在指定的時間點或時間間隔內(nèi)執(zhí)行任務。Timer 的缺點是不支持并發(fā)執(zhí)行和錯誤處理機制較弱。
• ScheduledExecutorService：Java 標準庫中提供的另一個定時調(diào)度工具，也可以在指定的時間點或時間間隔內(nèi)執(zhí)行任務。與 Timer 相比，ScheduledExecutorService 支持并發(fā)執(zhí)行和錯誤處理機制較強。
• Spring Task：Spring 框架中提供的一個定時調(diào)度工具，可以用于執(zhí)行定時任務、異步任務等。Spring Task 支持多種時間表達式、動態(tài)調(diào)整和錯誤處理機制。
• Quartz：一個用于定時調(diào)度的開源框架，可以在指定的時間點或時間間隔內(nèi)自動執(zhí)行任務。Quartz 支持多種配置方式和調(diào)度策略，功能豐富、靈活性高、易于集成并且可靠性較高。

Timer

Timer 是 Java 標準庫中提供的一個定時調(diào)度工具，可以在指定的時間點或時間間隔內(nèi)執(zhí)行任務。Timer 提供了多種調(diào)度方式和執(zhí)行策略，可以用于管理簡單的定時任務。

Timer 使用 TimerTask 類來表示要執(zhí)行的任務，TimerTask 是一個抽象類，需要繼承并實現(xiàn) run() 方法來定義具體的任務邏輯。Timer 還提供了多種調(diào)度方式，包括定時調(diào)度、周期性調(diào)度等。

以下是一個簡單的 Timer 示例：

import java.util.Timer;
import java.util.TimerTask;
public class MyTask extends TimerTask {
    public void run() {
        System.out.println("定時任務執(zhí)行了！");
    }
    public static void main(String[] args) {
        Timer timer = new Timer();
        MyTask task = new MyTask();
        timer.schedule(task, 5000); // 5秒后執(zhí)行任務
    }
}

在上述代碼中，我們定義了一個名為 MyTask 的 TimerTask 類，并在其中實現(xiàn)了 run() 方法來定義具體的任務邏輯。然后，在 main() 方法中創(chuàng)建了一個 Timer 實例，并使用 schedule() 方法來指定任務的執(zhí)行時間和執(zhí)行方式。

需要注意的是，Timer 的缺點是不支持并發(fā)執(zhí)行和錯誤處理機制較弱。如果需要實現(xiàn)復雜的定時任務，可以考慮使用其它的定時調(diào)度框架，例如 Quartz、ScheduledExecutorService 等。

ScheduledExecutorService

ScheduledExecutorService 基于 Executor 框架，使用 ThreadPoolExecutor 來實現(xiàn)任務的執(zhí)行和管理。

好的，下面是一個使用 ScheduledExecutorService 實現(xiàn)每天凌晨1點執(zhí)行任務的示例：

import java.time.LocalTime;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class MyTask implements Runnable {
    public void run() {
        System.out.println("定時任務執(zhí)行了！當前時間：" + LocalTime.now());
    }
    public static void main(String[] args) {
        ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);
        MyTask task = new MyTask();
        long initialDelay = calculateInitialDelay();
        executor.scheduleAtFixedRate(task, initialDelay, 24, TimeUnit.HOURS); // 每天凌晨1點執(zhí)行任務
    }
    private static long calculateInitialDelay() {
        LocalTime now = LocalTime.now();
        LocalTime target = LocalTime.of(1, 0, 0); // 目標執(zhí)行時間為每天凌晨1點
        if (now.isBefore(target)) {
            return Duration.between(now, target).toMillis();
        } else {
            return Duration.between(now, target.plusDays(1)).toMillis();
        }
    }
}

在上述代碼中，我們定義了一個名為 MyTask 的 Runnable 類，并在其中實現(xiàn)了 run() 方法來定義具體的任務邏輯。然后，在 main() 方法中創(chuàng)建了一個 ScheduledExecutorService 實例，并使用 scheduleAtFixedRate() 方法來指定任務的執(zhí)行時間和執(zhí)行方式。

為了實現(xiàn)每天凌晨1點執(zhí)行任務，我們先定義了一個 calculateInitialDelay() 方法來計算任務的初始延遲時間。該方法會根據(jù)當前時間和目標執(zhí)行時間計算出初始延遲時間，如果當前時間早于目標執(zhí)行時間，則將初始延遲時間設置為兩者時間差，否則將初始延遲時間設置為兩者時間差加上一天的時間差。

最后，我們使用 scheduleAtFixedRate() 方法來指定任務的執(zhí)行時間和執(zhí)行周期，其中 initialDelay 參數(shù)為初始延遲時間，period 參數(shù)為執(zhí)行周期，這里是每24小時執(zhí)行一次。

需要注意的是，為了獲取當前時間和計算時間差，我們使用了 Java 8 中的 LocalDate、LocalTime 和 Duration 類。如果使用的是 Java 7 或更早的版本，可以使用 Date、Calendar 等類來代替。

Spring Task

Spring Task（也稱為 Spring Scheduler）是 Spring 框架中提供的定時任務框架，可以在指定的時間點或時間間隔內(nèi)執(zhí)行任務。Spring Task 封裝了 Java 標準庫中的 Timer 和ScheduledExecutorService，提供了更加簡單和方便的定時任務管理方式。

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
@Component
public class MyTask {
    @Scheduled(cron = "0 0 1 * * ?") // 每天凌晨1點執(zhí)行任務
    public void execute() {
        System.out.println("定時任務執(zhí)行了！當前時間：" + new Date());
    }
}

在上述代碼中，我們定義了一個名為 MyTask 的類，并在其中使用 @Scheduled 注解來指定任務的執(zhí)行時間和執(zhí)行方式。這里使用了 cron 表達式來指定每天凌晨1點執(zhí)行任務。

@Scheduled注解支持多種參數(shù)設置，例如：

• fixedRate：表示每隔多少毫秒執(zhí)行一次。
• fixedDelay：表示延遲多少毫秒后執(zhí)行。
• initialDelay：表示啟動延遲多少毫秒后執(zhí)行第一次。
• cron：使用Cron表達式來指定執(zhí)行時間，例如“0 0 12 * * ?”表示每天中午12點執(zhí)行。

需要注意的是，@Scheduled注解只能用于Spring容器中的Bean中，因此需要將使用該注解的類標注為@Component或其他的Spring組件注解。

cron表達式

另外，如果想要快速生成 cron 表達式，可以使用在線 cron 表達式生成器，例如 cron.qqe2.com/ cron 表達式。

@EnableScheduling

使用@Scheduled需要@EnableScheduling 配合,默認 spring-boot-actuator 包會帶上@EnableScheduling  注解，從而給人一種默認開啟定時任務的錯覺。移除對應包之后，如果用戶沒有在自己項目中帶上 @EnableScheduling  注解，則定時任務不會生效。

Quartz

Quartz 使用 Job 和 Trigger 兩個核心概念來管理任務。Job 表示要執(zhí)行的任務，Trigger 表示任務的觸發(fā)器，即任務執(zhí)行的時間條件。Quartz 還提供了多種調(diào)度器和監(jiān)聽器，可以實現(xiàn)更加復雜的任務調(diào)度和任務管理。

以下是一個簡單的 Quartz 示例：

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.impl.StdSchedulerFactory;
public class MyJob implements Job {
    public void execute(JobExecutionContext context) throws JobExecutionException {
        System.out.println("定時任務執(zhí)行了！當前時間：" + new Date());
    }
    public static void main(String[] args) throws SchedulerException {
        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
        JobDetail job = JobBuilder.newJob(MyJob.class).withIdentity("myJob", "group1").build();
        Trigger trigger = TriggerBuilder.newTrigger().withIdentity("myTrigger", "group1")
                .startAt(DateBuilder.todayAt(1, 0, 0)).withSchedule(SimpleScheduleBuilder.repeatHourlyForever())
                .build();
        scheduler.scheduleJob(job, trigger);
        scheduler.start();
    }
}

在上述代碼中，我們定義了一個名為 MyJob 的 Job 類，并在其中實現(xiàn)了 execute() 方法來定義具體的任務邏輯。然后，在 main() 方法中創(chuàng)建了一個 Scheduler 實例，并使用 JobBuilder 和 TriggerBuilder 來定義任務和觸發(fā)器。這里我們使用 SimpleScheduleBuilder 來指定任務的執(zhí)行間隔，即每小時執(zhí)行一次。

Quartz 還支持多種觸發(fā)器類型和調(diào)度器類型，例如 CronTrigger、CalendarIntervalTrigger、JobStoreTX 等，可以根據(jù)具體的需求進行選擇和配置。

以上就是SpringBoot定時調(diào)度之Timer與Quartz詳解的詳細內(nèi)容，更多關于SpringBoot定時的資料請關注腳本之家其它相關文章！

最新評論