在企業級應用開發中，定時任務是一個非常常見的需求。比如每天凌晨統計前一天的訂單數據、定期清理臨時文件、發送營銷郵件等。Spring Boot 提供了多種實現定時任務的方式，本文將從入門到進階，全面剖析幾種主流的實現方案，並通過實際案例幫助你選擇最適合自己項目的方案。

一、Spring Boot 實現定時任務的四種方式

Spring Boot 中實現定時任務主要有四種方式：

1. @Scheduled註解（Spring Boot 內置）
2. Spring Task（可編程方式動態管理任務）
3. Quartz（功能強大的任務調度框架）
4. XXL-Job（分佈式任務調度平台）

下面我們逐一詳細介紹。

二、@Scheduled 註解（最簡單的方式）

1. 基本使用

這是 Spring Boot 內置的最簡單實現方式，只需兩步即可完成：

步驟 1：啓用定時任務

在啓動類上添加@EnableScheduling註解：

@SpringBootApplication
@EnableScheduling
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}

步驟 2：創建定時任務類

@Component
public class ScheduledTasks {

    private static final Logger log = LoggerFactory.getLogger(ScheduledTasks.class);
    private static final SimpleDateFormat dateFormat = new SimpleDateFormat("HH:mm:ss");

    // 每隔5秒執行一次
    @Scheduled(fixedRate = 5000)
    public void reportCurrentTime() {
        log.info("當前時間：{}", dateFormat.format(new Date()));
    }

    // 每天凌晨1點執行
    @Scheduled(cron = "0 0 1 * * ?")
    public void dailyTask() {
        log.info("執行每日任務");
    }
}

2. @Scheduled 註解的幾種模式

@Scheduled註解支持多種執行模式，使用場景各不相同：

• fixedRate：固定速率執行，任務按照嚴格的時間間隔執行，不考慮上次任務的執行時間
• fixedDelay：固定延遲執行，上次執行完成後，延遲指定時間再執行
• initialDelay：首次延遲執行，與 fixedRate 或 fixedDelay 結合使用
• cron：使用 cron 表達式指定執行時間

下面是幾個實際例子：

// 固定速率：每3秒執行一次，不管任務執行要多久
@Scheduled(fixedRate = 3000)
public void taskWithFixedRate() {
    log.info("固定速率任務開始");
    // 任務邏輯
}

// 固定延遲：上次執行完成後等待3秒再執行
@Scheduled(fixedDelay = 3000)
public void taskWithFixedDelay() {
    log.info("固定延遲任務開始");
    // 任務邏輯
}

// 組合使用：首次延遲5秒，之後每3秒執行一次
@Scheduled(initialDelay = 5000, fixedRate = 3000)
public void taskWithInitialDelay() {
    log.info("首次延遲任務開始");
    // 任務邏輯
}

// Cron表達式：每分鐘的第0秒執行一次
@Scheduled(cron = "0 * * * * ?")
public void taskWithCron() {
    log.info("Cron任務開始");
    // 任務邏輯
}

3. Cron 表達式詳解

Cron 表達式格式為：秒 分 時 日 月 周（年），其中年是可選的。當"日"和"周"字段同時存在時，必須有一個設為?來避免衝突。

下面是一些常用的 Cron 表達式示例：

4. @Scheduled 的線程池配置

默認情況下，Spring Boot 中的@Scheduled任務是由單線程執行的，這意味着如果一個任務執行時間過長，會阻塞其他任務。在實際應用中，通常需要配置線程池：

@Configuration
public class SchedulingConfig implements SchedulingConfigurer {

    @Override
    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
        // 創建一個線程池調度器
        ThreadPoolTaskScheduler taskScheduler = new ThreadPoolTaskScheduler();
        // 設置線程池大小
        taskScheduler.setPoolSize(10);
        // 設置線程名前綴
        taskScheduler.setThreadNamePrefix("scheduled-task-pool-");
        // 設置等待任務完成再關閉線程池
        taskScheduler.setWaitForTasksToCompleteOnShutdown(true);
        // 等待時間（單位：秒）
        taskScheduler.setAwaitTerminationSeconds(60);
        taskScheduler.initialize();

        taskRegistrar.setTaskScheduler(taskScheduler);
    }
}

這樣配置後，多個定時任務可以並行執行，互不影響。

下面是單線程和多線程執行的對比時序圖：

三、Spring Task（動態管理任務）

如果需要在運行時動態管理任務（創建、修改、刪除），可以使用 Spring Task：

@Service
public class DynamicTaskService {

    @Autowired
    private ThreadPoolTaskScheduler taskScheduler;

    // 存儲任務Future的Map
    private final Map<String, ScheduledFuture<?>> scheduledTasks = new ConcurrentHashMap<>();

    // 添加一個新的定時任務
    public void addCronTask(String taskId, String cronExpression, Runnable task) {
        // 驗證cronExpression是否有效
        if (taskId == null || taskId.trim().isEmpty()) {
            throw new IllegalArgumentException("任務ID不能為空");
        }

        try {
            // 檢查cron表達式的合法性
            if (!CronExpression.isValidExpression(cronExpression)) {
                throw new IllegalArgumentException("無效的cron表達式: " + cronExpression);
            }
        } catch (Exception e) {
            throw new IllegalArgumentException("cron表達式錯誤: " + e.getMessage(), e);
        }

        // 如果任務已存在，先移除
        if (scheduledTasks.containsKey(taskId)) {
            cancelTask(taskId);
        }

        // 創建觸發器
        CronTrigger trigger = new CronTrigger(cronExpression);
        // 調度任務並保存future
        ScheduledFuture<?> future = taskScheduler.schedule(task, trigger);
        scheduledTasks.put(taskId, future);
    }

    // 取消任務
    public boolean cancelTask(String taskId) {
        ScheduledFuture<?> future = scheduledTasks.get(taskId);
        if (future != null) {
            boolean cancelled = future.cancel(true);
            if (cancelled) {
                scheduledTasks.remove(taskId);
            }
            return cancelled;
        }
        return false;
    }

    // 獲取所有任務ID
    public Set<String> getAllTaskIds() {
        return scheduledTasks.keySet();
    }
}

這種方式特別適合從配置中心或數據庫加載定時任務配置的場景。

四、Quartz（功能完備的調度框架）

對於需要持久化、集羣、精確調度的場景，Quartz 是更好的選擇。

1. 基本配置

首先添加 Quartz 依賴：

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

然後配置 Quartz：

# 應用屬性文件中配置Quartz
spring.quartz.job-store-type=jdbc
spring.quartz.properties.org.quartz.scheduler.instanceName=MyClusteredScheduler
spring.quartz.properties.org.quartz.scheduler.instanceId=AUTO
spring.quartz.properties.org.quartz.jobStore.class=org.quartz.impl.jdbcjobstore.JobStoreTX
spring.quartz.properties.org.quartz.jobStore.driverDelegateClass=org.quartz.impl.jdbcjobstore.StdJDBCDelegate
spring.quartz.properties.org.quartz.jobStore.tablePrefix=QRTZ_
spring.quartz.properties.org.quartz.jobStore.isClustered=true
spring.quartz.properties.org.quartz.jobStore.clusterCheckinInterval=20000
spring.quartz.properties.org.quartz.threadPool.class=org.quartz.simpl.SimpleThreadPool
spring.quartz.properties.org.quartz.threadPool.threadCount=10
spring.quartz.properties.org.quartz.threadPool.threadPriority=5
spring.quartz.jdbc.initialize-schema=always

2. 創建 Quartz 任務

定義 Job

@DisallowConcurrentExecution  // 防止同一個任務實例被併發執行
@PersistJobDataAfterExecution // 更新JobDataMap
public class DataCleanupJob implements Job {

    private static final Logger log = LoggerFactory.getLogger(DataCleanupJob.class);

    @Autowired
    private DataCleanupService dataCleanupService;

    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        JobDataMap dataMap = context.getJobDetail().getJobDataMap();
        int daysToKeep = dataMap.getInt("daysToKeep");
        String dataType = dataMap.getString("dataType");

        log.info("開始清理{}數據，保留{}天", dataType, daysToKeep);

        try {
            // 使用業務主鍵或狀態字段確保冪等性（避免重複處理）
            int cleanedCount = dataCleanupService.cleanupData(dataType, daysToKeep);
            log.info("成功清理{}條{}數據", cleanedCount, dataType);

            // 更新JobDataMap，記錄最後執行時間
            dataMap.put("lastExecutionTime", new Date().getTime());
            dataMap.put("lastCleanedCount", cleanedCount);
        } catch (Exception e) {
            log.error("清理數據失敗", e);
            throw new JobExecutionException(e);
        }
    }
}

註冊 Job 和 Trigger

@Configuration
public class QuartzConfig {

    @Bean
    public JobDetail dataCleanupJobDetail() {
        return JobBuilder.newJob(DataCleanupJob.class)
                .withIdentity("dataCleanupJob", "maintenance")
                .usingJobData("daysToKeep", 30)
                .usingJobData("dataType", "logs")
                .storeDurably()
                .build();
    }

    @Bean
    public Trigger dataCleanupTrigger() {
        // 創建CronScheduleBuilder
        CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule("0 0 1 * * ?");

        // 配置失敗重試策略
        scheduleBuilder.withMisfireHandlingInstructionFireAndProceed();

        return TriggerBuilder.newTrigger()
                .forJob(dataCleanupJobDetail())
                .withIdentity("dataCleanupTrigger", "maintenance")
                .withDescription("每天凌晨1點執行日誌清理")
                .withSchedule(scheduleBuilder)
                .build();
    }
}

3. Quartz 任務管理服務

創建一個服務類用於動態管理 Quartz 任務：

@Service
public class QuartzJobService {

    @Autowired
    private Scheduler scheduler;

    // 添加新任務
    public void addJob(Class<? extends Job> jobClass, String jobName, String jobGroup,
                      String cronExpression, Map<String, Object> jobData) throws Exception {

        JobDetail jobDetail = JobBuilder.newJob(jobClass)
                .withIdentity(jobName, jobGroup)
                .storeDurably()
                .build();

        // 設置JobDataMap
        if (jobData != null && !jobData.isEmpty()) {
            jobDetail.getJobDataMap().putAll(jobData);
        }

        CronTrigger trigger = TriggerBuilder.newTrigger()
                .withIdentity(jobName + "Trigger", jobGroup)
                .withSchedule(CronScheduleBuilder.cronSchedule(cronExpression))
                .build();

        scheduler.scheduleJob(jobDetail, trigger);
    }

    // 修改任務執行時間
    public void updateJobCron(String jobName, String jobGroup, String cronExpression) throws Exception {
        TriggerKey triggerKey = TriggerKey.triggerKey(jobName + "Trigger", jobGroup);
        CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);

        if (trigger == null) {
            throw new IllegalArgumentException("找不到對應的觸發器");
        }

        // 創建新的觸發器
        CronTrigger newTrigger = TriggerBuilder.newTrigger()
                .withIdentity(triggerKey)
                .withSchedule(CronScheduleBuilder.cronSchedule(cronExpression))
                .build();

        // 重新調度任務
        scheduler.rescheduleJob(triggerKey, newTrigger);
    }

    // 暫停任務
    public void pauseJob(String jobName, String jobGroup) throws Exception {
        JobKey jobKey = JobKey.jobKey(jobName, jobGroup);
        scheduler.pauseJob(jobKey);
    }

    // 恢復任務
    public void resumeJob(String jobName, String jobGroup) throws Exception {
        JobKey jobKey = JobKey.jobKey(jobName, jobGroup);
        scheduler.resumeJob(jobKey);
    }

    // 刪除任務
    public void deleteJob(String jobName, String jobGroup) throws Exception {
        JobKey jobKey = JobKey.jobKey(jobName, jobGroup);
        scheduler.deleteJob(jobKey);
    }

    // 獲取所有任務
    public List<Map<String, Object>> getAllJobs() throws Exception {
        List<Map<String, Object>> jobList = new ArrayList<>();

        for (String groupName : scheduler.getJobGroupNames()) {
            for (JobKey jobKey : scheduler.getJobKeys(GroupMatcher.jobGroupEquals(groupName))) {
                Map<String, Object> jobMap = new HashMap<>();
                jobMap.put("jobName", jobKey.getName());
                jobMap.put("jobGroup", jobKey.getGroup());

                List<? extends Trigger> triggers = scheduler.getTriggersOfJob(jobKey);
                for (Trigger trigger : triggers) {
                    jobMap.put("nextFireTime", trigger.getNextFireTime());

                    if (trigger instanceof CronTrigger) {
                        CronTrigger cronTrigger = (CronTrigger) trigger;
                        jobMap.put("cronExpression", cronTrigger.getCronExpression());
                    }

                    Trigger.TriggerState triggerState = scheduler.getTriggerState(trigger.getKey());
                    jobMap.put("triggerState", triggerState.name());
                }

                jobList.add(jobMap);
            }
        }

        return jobList;
    }
}

4. Quartz 集羣配置

Quartz 支持集羣部署，以便在多個節點上實現高可用和負載均衡。關鍵是使用數據庫來協調各個節點：

Quartz 集羣通過數據庫鎖實現任務互斥的原理如下圖所示。當任務觸發時，集羣中的節點會競爭獲取數據庫鎖（SELECT FOR UPDATE），確保同一任務只在一個節點上執行。

為了啓用 Quartz 集羣，首先需要創建 Quartz 相關的數據庫表。Quartz 提供了各種數據庫的初始化腳本，例如 MySQL 腳本位於：

quartz-2.3.0/src/main/resources/org/quartz/impl/jdbcjobstore/tables_mysql.sql

其中qrtz_locks表是實現分佈式鎖的關鍵，存儲鎖名稱並通過數據庫行鎖機制確保任務互斥。

五、XXL-Job（分佈式任務調度平台）

對於複雜的分佈式系統，XXL-Job 提供了更全面的解決方案，包括可視化管理界面、任務分片、失敗告警等特性。

1. 基本架構

XXL-Job 由兩部分組成：

• 調度中心：負責管理任務、調度任務
• 執行器：負責接收調度並執行任務

2. 集成步驟

步驟 1：添加依賴

<dependency>
    <groupId>com.xuxueli</groupId>
    <artifactId>xxl-job-core</artifactId>
    <version>2.3.1</version>
</dependency>

步驟 2：配置執行器

# application.properties
xxl.job.admin.addresses=http://localhost:8080/xxl-job-admin
xxl.job.accessToken=default_token
xxl.job.executor.appname=my-xxl-job-executor
xxl.job.executor.ip=
xxl.job.executor.port=9999
xxl.job.executor.logpath=/data/applogs/xxl-job/jobhandler
xxl.job.executor.logretentiondays=30

步驟 3：創建配置類

@Configuration
public class XxlJobConfig {

    private Logger logger = LoggerFactory.getLogger(XxlJobConfig.class);

    @Value("${xxl.job.admin.addresses}")
    private String adminAddresses;

    @Value("${xxl.job.accessToken}")
    private String accessToken;

    @Value("${xxl.job.executor.appname}")
    private String appname;

    @Value("${xxl.job.executor.ip}")
    private String ip;

    @Value("${xxl.job.executor.port}")
    private int port;

    @Value("${xxl.job.executor.logpath}")
    private String logPath;

    @Value("${xxl.job.executor.logretentiondays}")
    private int logRetentionDays;

    @Bean
    public XxlJobSpringExecutor xxlJobExecutor() {
        logger.info(">>>>>>>>>>> xxl-job config init.");
        XxlJobSpringExecutor xxlJobSpringExecutor = new XxlJobSpringExecutor();
        xxlJobSpringExecutor.setAdminAddresses(adminAddresses);
        xxlJobSpringExecutor.setAppname(appname);
        xxlJobSpringExecutor.setIp(ip);
        xxlJobSpringExecutor.setPort(port);
        xxlJobSpringExecutor.setAccessToken(accessToken);
        xxlJobSpringExecutor.setLogPath(logPath);
        xxlJobSpringExecutor.setLogRetentionDays(logRetentionDays);

        return xxlJobSpringExecutor;
    }
}

步驟 4：創建任務執行器

@Component
public class OrderTaskHandler {

    private static Logger logger = LoggerFactory.getLogger(OrderTaskHandler.class);

    @Autowired
    private OrderService orderService;

    @XxlJob("cancelTimeoutOrderHandler")
    public void cancelTimeoutOrder() {
        logger.info("開始處理超時未支付訂單...");

        try {
            // 查詢所有創建時間超過30分鐘且狀態為未支付的訂單
            Date thirtyMinutesAgo = new Date(System.currentTimeMillis() - 30 * 60 * 1000);

            // 為避免一次處理過多數據導致內存問題，使用分頁處理
            int pageSize = 100;
            int pageNum = 1;
            int total = 0;

            while (true) {
                List<Order> timeoutOrders = orderService.findTimeoutOrders(thirtyMinutesAgo, pageNum, pageSize);
                if (timeoutOrders.isEmpty()) {
                    break;
                }

                for (Order order : timeoutOrders) {
                    try {
                        // 使用訂單狀態確保冪等性，避免重複取消
                        orderService.cancelOrder(order.getId());
                        total++;
                    } catch (Exception e) {
                        logger.error("取消訂單{}失敗", order.getId(), e);
                        // 可以記錄失敗訂單，後續重試
                    }
                }

                pageNum++;
            }

            logger.info("成功取消{}個超時訂單", total);

        } catch (Exception e) {
            logger.error("處理超時訂單異常", e);
            // 拋出異常，XXL-Job會記錄任務失敗，並根據配置重試
            throw new RuntimeException(e);
        }
    }
}

3. 分片任務

XXL-Job 支持分片任務，適合需要並行處理大量數據的場景：

@Component
public class UserPointsHandler {

    private static Logger logger = LoggerFactory.getLogger(UserPointsHandler.class);

    @Autowired
    private UserService userService;

    @XxlJob("calculateUserPointsHandler")
    public void calculateUserPoints() {
        // 分片參數
        int shardIndex = XxlJobHelper.getShardIndex();  // 當前分片索引
        int shardTotal = XxlJobHelper.getShardTotal();  // 總分片數

        logger.info("用户積分計算任務開始，當前分片:{}/{}", shardIndex, shardTotal);

        try {
            // 任務參數（可在XXL-Job管理界面配置）
            String param = XxlJobHelper.getJobParam();
            Integer pointsToAdd = StringUtils.hasText(param) ? Integer.parseInt(param) : 10;

            // 根據用户ID分片，例如：用户ID % 分片總數 == 當前分片索引
            List<User> users = userService.findUsersForShard(shardIndex, shardTotal);

            int count = 0;
            for (User user : users) {
                try {
                    userService.addPoints(user.getId(), pointsToAdd);
                    count++;
                } catch (Exception e) {
                    logger.error("為用户{}添加積分失敗", user.getId(), e);
                }
            }

            logger.info("分片{}/{}完成，成功處理{}個用户", shardIndex, shardTotal, count);

        } catch (Exception e) {
            logger.error("用户積分計算任務異常", e);
            // 設置任務結果和錯誤信息
            XxlJobHelper.handleFail("任務執行異常: " + e.getMessage());
            return;
        }

        // 設置任務結果
        XxlJobHelper.handleSuccess("任務執行成功");
    }
}

這個分片任務的特點是：

1. 通過XxlJobHelper.getShardIndex()獲取當前分片索引
2. 通過XxlJobHelper.getShardTotal()獲取總分片數
3. 根據分片參數過濾需要處理的數據
4. 每個執行器只處理屬於自己分片的數據

分片任務與路由策略結合使用可以實現更精細的負載均衡：分片決定每個執行器處理哪部分數據，路由策略決定調度中心將任務路由到哪些執行器。

六、實際應用場景與方案選擇

1. 單體應用，簡單定時任務

場景：每天統計網站訪問量

推薦方案：@Scheduled註解

@Component
public class StatisticsTask {

    @Autowired
    private StatisticsService statisticsService;

    // 每天凌晨2點執行
    @Scheduled(cron = "0 0 2 * * ?")
    public void dailyStatistics() {
        statisticsService.calculateDailyStatistics();
    }
}

2. 需要動態調整執行時間的任務

場景：根據業務需求調整報表生成時間

推薦方案：Spring Task

@RestController
@RequestMapping("/api/tasks")
public class TaskController {

    @Autowired
    private DynamicTaskService taskService;

    @Autowired
    private ReportService reportService;

    @PostMapping("/report")
    public ResponseEntity<String> updateReportSchedule(@RequestParam String cronExpression) {
        try {
            taskService.addCronTask("generateReport", cronExpression, () -> {
                reportService.generateDailyReport();
            });
            return ResponseEntity.ok("報表任務調度時間已更新為: " + cronExpression);
        } catch (Exception e) {
            return ResponseEntity.badRequest().body("更新失敗: " + e.getMessage());
        }
    }

    @DeleteMapping("/report")
    public ResponseEntity<String> cancelReportTask() {
        boolean result = taskService.cancelTask("generateReport");
        if (result) {
            return ResponseEntity.ok("報表任務已取消");
        } else {
            return ResponseEntity.notFound().build();
        }
    }
}

3. 分佈式應用，需要集羣高可用

場景：訂單系統需要定期清理過期訂單，要求高可用

推薦方案：Quartz 集羣

@Service
public class OrderCleanupService {

    @Autowired
    private QuartzJobService quartzJobService;

    public void initOrderCleanupJob() throws Exception {
        Map<String, Object> jobData = new HashMap<>();
        jobData.put("daysToKeep", 90);
        jobData.put("orderStatus", "CANCELED");

        quartzJobService.addJob(
            OrderCleanupJob.class,
            "orderCleanupJob",
            "orderManagement",
            "0 0 3 * * ?",  // 每天凌晨3點執行
            jobData
        );
    }
}

// Job實現
public class OrderCleanupJob implements Job {

    @Autowired
    private OrderService orderService;

    @Override
    @Transactional
    public void execute(JobExecutionContext context) throws JobExecutionException {
        JobDataMap dataMap = context.getJobDetail().getJobDataMap();
        int daysToKeep = dataMap.getInt("daysToKeep");
        String status = dataMap.getString("orderStatus");

        try {
            int count = orderService.cleanupOldOrders(daysToKeep, status);
            // 記錄執行結果
            dataMap.put("lastExecutionTime", System.currentTimeMillis());
            dataMap.put("lastCleanupCount", count);
        } catch (Exception e) {
            throw new JobExecutionException("清理訂單失敗", e);
        }
    }
}

4. 大規模分佈式系統，需要任務分片

場景：電商大促前，需要為所有用户發放優惠券

推薦方案：XXL-Job

@Component
public class CouponDistributionHandler {

    @Autowired
    private CouponService couponService;

    @Autowired
    private UserService userService;

    @XxlJob("distributeCouponHandler")
    public void distributeCoupon() {
        int shardIndex = XxlJobHelper.getShardIndex();
        int shardTotal = XxlJobHelper.getShardTotal();

        String couponId = XxlJobHelper.getJobParam();
        if (StringUtils.isEmpty(couponId)) {
            XxlJobHelper.handleFail("優惠券ID不能為空");
            return;
        }

        try {
            // 根據用户ID分片
            List<User> users = userService.findActiveUsersForShard(shardIndex, shardTotal);

            int successCount = 0;
            for (User user : users) {
                try {
                    // 檢查冪等性，避免重複發放
                    if (!couponService.hasCoupon(user.getId(), couponId)) {
                        couponService.issueCoupon(user.getId(), couponId);
                        successCount++;
                    }
                } catch (Exception e) {
                    log.error("為用户{}發放優惠券{}失敗", user.getId(), couponId, e);
                }
            }

            XxlJobHelper.handleSuccess(String.format("成功為%d個用户發放優惠券", successCount));
        } catch (Exception e) {
            log.error("發放優惠券任務異常", e);
            XxlJobHelper.handleFail(e.getMessage());
        }
    }
}

七、常見問題與解決方案

1. 任務重複執行問題

在分佈式環境中，如果多個節點部署了相同的定時任務，可能導致任務重複執行。解決方案：

• 使用分佈式鎖：基於 Redis 或 ZooKeeper 實現分佈式鎖
• 使用 Quartz 集羣模式：自動處理任務互斥
• 使用 XXL-Job 調度中心：統一管理任務調度

以下是使用 Redis 分佈式鎖的示例：

@Component
public class DistributedTask {

    @Autowired
    private StringRedisTemplate redisTemplate;

    @Autowired
    private TaskService taskService;

    @Scheduled(cron = "0 0 12 * * ?")
    public void executeTask() {
        String lockKey = "task_lock:daily_task";
        // 獲取鎖，60秒超時
        Boolean acquired = redisTemplate.opsForValue().setIfAbsent(lockKey, "locked", 60, TimeUnit.SECONDS);

        if (Boolean.TRUE.equals(acquired)) {
            try {
                // 獲取鎖成功，執行任務
                taskService.executeDailyTask();
            } finally {
                // 釋放鎖
                redisTemplate.delete(lockKey);
            }
        } else {
            // 未獲取到鎖，任務已被其他節點執行
            log.info("任務已被其他節點執行，跳過");
        }
    }
}

2. 任務執行時間過長問題

對於執行時間長的任務，可能會影響其他任務調度或導致任務重疊執行。解決方案：

• 異步執行：結合@Async註解或線程池
• 任務分片：將大任務拆分為多個小任務並行執行
• 增加超時控制：避免任務無限期執行

@Service
public class ReportService {

    @Autowired
    private ThreadPoolTaskExecutor taskExecutor;

    // 異步執行耗時任務
    public Future<String> generateReportAsync() {
        return taskExecutor.submit(() -> {
            // 設置超時控制
            try {
                return CompletableFuture.supplyAsync(this::generateReport)
                        .orTimeout(30, TimeUnit.MINUTES)
                        .get();
            } catch (TimeoutException e) {
                log.error("報表生成超時");
                throw new RuntimeException("報表生成超時", e);
            } catch (Exception e) {
                log.error("報表生成異常", e);
                throw new RuntimeException("報表生成失敗", e);
            }
        });
    }

    private String generateReport() {
        // 報表生成邏輯
        return "報表生成完成";
    }
}

3. 任務失敗重試與告警

任務執行失敗時，需要有重試機制和告警通知。解決方案：

• Quartz 重試：使用SimpleTrigger配置重試次數和間隔
• XXL-Job 內置重試：在管理界面配置失敗重試次數
• 自定義重試邏輯：結合 Spring Retry 實現

// XXL-Job任務失敗重試示例
@XxlJob("retryableTask")
public void executeWithRetry() {
    try {
        // 業務邏輯
        someBusinessLogic();
    } catch (Exception e) {
        // 記錄異常，任務將根據XXL-Job管理界面的重試配置自動重試
        XxlJobHelper.log("任務執行失敗: " + e.getMessage());
        throw e;  // 拋出異常，觸發重試
    }
}

// Spring Retry示例
@Service
public class RetryService {

    // 最多重試3次，間隔1秒
    @Retryable(value = {DataAccessException.class}, maxAttempts = 3, backoff = @Backoff(delay = 1000))
    public void doWithRetry() {
        // 可能失敗的業務邏輯
    }

    // 所有重試都失敗後執行
    @Recover
    public void recover(DataAccessException e) {
        // 發送告警通知
        notifyAdmins("任務執行失敗，請檢查: " + e.getMessage());
    }
}

八、四種實現方式對比

九、總結

本文詳細介紹了 Spring Boot 中實現定時任務的四種方式：

1. @Scheduled 註解：最簡單的方式，適合單體應用的簡單定時任務。
2. Spring Task：支持動態管理任務，適合需要在運行時調整任務的場景。
3. Quartz：功能完備的調度框架，支持持久化和集羣，適合需要高可用的企業級應用。
4. XXL-Job：分佈式任務調度平台，提供可視化管理界面和任務分片功能，適合大規模分佈式系統。

在選擇實現方式時，需要根據具體需求（如併發要求、持久化需求、分佈式部署等）進行權衡。對於簡單場景，@Scheduled 足夠使用；對於複雜的企業級應用，Quartz 或 XXL-Job 會是更好的選擇。

無論選擇哪種方式，都需要注意任務的冪等性設計、失敗重試機制、性能優化以及監控告警，確保定時任務能夠穩定、可靠地運行。

希望本文能幫助你在 Spring Boot 項目中選擇和實現適合自己需求的定時任務方案！