Java 后端 / 系统课时

实现可控定时任务

实现可控定时任务

本课将实现一个可在多实例环境安全运行的周期任务:使用外部化 Cron 与明确时区触发,通过数据库租约锁选出唯一执行者,并用独立工作线程、超时取消和日志验证控制任务边界。

学习目标

  • 正确选择 cron、fixedDelay 与 fixedRate,并显式指定业务时区。
  • 使用数据库租约锁避免多个应用实例同时执行同一任务。
  • 为任务设置执行超时、释放锁规则和可验证的运行日志。

选择触发方式与时区

@Scheduled 提供三类常用触发方式,它们表达的业务语义不同。

方式 下一次触发基准 适用场景
cron 日历时间 对账、结算、报表等固定时点任务
fixedDelay 上一次执行结束 不允许连续追赶的轮询任务
fixedRate 上一次计划开始时间 采样、刷新等强调频率的短任务

日历任务应始终填写 zone,不要依赖服务器默认时区。存在夏令时的地区可能出现某个本地时间被跳过或重复,关键账务任务应在需求中明确补跑与去重规则。

建立数据库租约锁

多实例部署时,每个实例都会收到相同的调度触发。下面使用 MySQL 建立一行租约记录,通过原子 UPDATE 竞争锁。所有时间都由数据库的 UTC 时钟生成,避免应用节点时钟不一致。

sql
CREATE TABLE IF NOT EXISTS scheduled_lock (
    lock_name VARCHAR(100) PRIMARY KEY,
    locked_until TIMESTAMP(6) NOT NULL,
    locked_by VARCHAR(100) NULL,
    updated_at TIMESTAMP(6) NOT NULL
        DEFAULT CURRENT_TIMESTAMP(6)
        ON UPDATE CURRENT_TIMESTAMP(6)
);

INSERT IGNORE INTO scheduled_lock (
    lock_name,
    locked_until,
    locked_by
) VALUES (
    'settlement-close',
    UTC_TIMESTAMP(6),
    NULL
);

预期结果

text
scheduled_lock 表创建成功,并且 settlement-close 只有一条锁记录;重复执行脚本不会插入重复主键。

租约锁不是永久互斥锁。实例拿锁时把 locked_until 推到未来;正常结束后主动释放。实例崩溃时不需要人工解锁,租约到期后其他实例可以重新竞争。

多实例定时任务、数据库租约锁与超时控制流程图

配置调度器

把 Cron 与时区放在配置文件中,便于不同环境独立调整。调度线程只负责触发和等待结果,真正的业务逻辑由独立工作线程执行。

yaml
spring:
  task:
    scheduling:
      pool:
        size: 2
      thread-name-prefix: scheduler-
      shutdown:
        await-termination: true
        await-termination-period: 30s

jobs:
  settlement:
    cron: "0 * * * * *"
    zone: "Asia/Shanghai"

该配置会在每分钟第 0 秒触发任务,并使用两个调度线程。修改 Cron 后应重新启动应用,并从启动日志或测试环境运行记录确认新配置已加载。

实现锁、超时与任务主体

下面示例可放入已有的 Spring Boot 3 JDBC 项目。锁租约为 90 秒,任务超时为 30 秒,因此即使任务失控,也为取消与释放留出了安全余量。

java
package com.example.scheduleddemo;

import java.time.Duration;
import java.util.UUID;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

@SpringBootApplication
@EnableScheduling
public class ScheduledJobApplication {

    public static void main(String[] args) {
        SpringApplication.run(ScheduledJobApplication.class, args);
    }

    @Bean(destroyMethod = "shutdown")
    ExecutorService scheduledJobExecutor() {
        return Executors.newFixedThreadPool(2);
    }
}

@Component
class DbLeaseLock {

    private final JdbcTemplate jdbcTemplate;

    DbLeaseLock(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

    boolean tryAcquire(
            String lockName,
            String owner,
            Duration lease) {
        String sql = """
                UPDATE scheduled_lock
                SET locked_until = TIMESTAMPADD(
                        SECOND, ?, UTC_TIMESTAMP(6)),
                    locked_by = ?
                WHERE lock_name = ?
                  AND locked_until <= UTC_TIMESTAMP(6)
                """;

        return jdbcTemplate.update(
                sql,
                lease.toSeconds(),
                owner,
                lockName) == 1;
    }

    void release(String lockName, String owner) {
        String sql = """
                UPDATE scheduled_lock
                SET locked_until = UTC_TIMESTAMP(6),
                    locked_by = NULL
                WHERE lock_name = ?
                  AND locked_by = ?
                """;

        jdbcTemplate.update(sql, lockName, owner);
    }
}

@Component
class SettlementCloseJob {

    private static final Logger log =
            LoggerFactory.getLogger(SettlementCloseJob.class);
    private static final String LOCK_NAME = "settlement-close";
    private static final Duration LEASE = Duration.ofSeconds(90);

    private final DbLeaseLock lock;
    private final ExecutorService worker;
    private final String instanceId =
            System.getenv().getOrDefault("HOSTNAME", "local")
                    + "-" + UUID.randomUUID();

    SettlementCloseJob(
            DbLeaseLock lock,
            ExecutorService scheduledJobExecutor) {
        this.lock = lock;
        this.worker = scheduledJobExecutor;
    }

    @Scheduled(
            cron = "${jobs.settlement.cron}",
            zone = "${jobs.settlement.zone}")
    public void trigger() {
        if (!lock.tryAcquire(LOCK_NAME, instanceId, LEASE)) {
            log.info("job={} instance={} skipped: lock is held",
                    LOCK_NAME, instanceId);
            return;
        }

        Future<?> future = null;
        boolean releaseNow = true;
        try {
            future = worker.submit(this::closeSettlement);
            future.get(30, TimeUnit.SECONDS);
            log.info("job={} instance={} completed",
                    LOCK_NAME, instanceId);
        } catch (TimeoutException error) {
            releaseNow = false;
            future.cancel(true);
            log.error("job={} instance={} timed out",
                    LOCK_NAME, instanceId, error);
        } catch (ExecutionException error) {
            log.error("job={} instance={} failed",
                    LOCK_NAME, instanceId, error.getCause());
        } catch (InterruptedException error) {
            releaseNow = false;
            Thread.currentThread().interrupt();
            if (future != null) {
                future.cancel(true);
            }
            log.error("job={} instance={} interrupted",
                    LOCK_NAME, instanceId, error);
        } finally {
            if (releaseNow) {
                lock.release(LOCK_NAME, instanceId);
            } else {
                log.warn("job={} keeps lease until expiration",
                        LOCK_NAME);
            }
        }
    }

    private void closeSettlement() {
        try {
            // 替换为具有幂等条件的结算关闭逻辑。
            Thread.sleep(2_000);
        } catch (InterruptedException error) {
            Thread.currentThread().interrupt();
            throw new IllegalStateException(
                    "settlement task interrupted", error);
        }
    }
}

预期结果

text
应用启动后会按配置的 Cron 注册任务;每次触发只有成功更新租约记录的实例执行 closeSettlement,任务超过 30 秒会被取消并记录超时。

分别启动两个连接同一数据库的实例:

bash
SERVER_PORT=8081 ./mvnw spring-boot:run
SERVER_PORT=8082 ./mvnw spring-boot:run

预期输出

text
<TIME> INFO  job=settlement-close instance=<ID> completed
<TIME> INFO  job=settlement-close instance=<ID> skipped: lock is held

两个实例谁先获得锁并不固定;时间、实例标识和日志顺序以实际运行结果为准。每个触发周期应只有一条 completed,另一个实例记录 skipped。

处理关键边界

租约时长必须大于任务超时,并预留网络、数据库和释放锁的余量。任务可能长期运行时,应增加续租机制,而不是简单设置一个极大的过期时间。

Future.cancel(true) 只能发送中断信号。示例在超时或调度线程中断时不立即释放锁,而是让租约自然到期;业务代码仍必须响应线程中断,数据库、HTTP 和消息客户端也要设置连接与读取超时。

分布式锁只能减少并发执行,不能提供“严格只执行一次”。实例可能在业务提交成功后、记录完成日志前崩溃,因此任务主体仍要使用业务唯一键、状态条件或幂等表防止重复处理。

释放锁时同时匹配 lock_name 与 locked_by,可以避免旧执行者在租约过期后误删新执行者的锁。数据库不可用时应让本次任务失败并告警,不能绕过锁直接执行。

验收任务行为

在测试环境完成以下验证:

  • 同时启动两个实例,连续观察多个周期,每个周期只有一个实例执行。
  • 把任务休眠时间临时调到 35 秒,确认出现超时日志并收到中断。
  • 执行中强制停止持锁实例,确认 90 秒租约到期后另一实例能够接管。
  • 重复触发相同业务批次,确认业务数据不会被重复结算。
按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

实现可控定时任务

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通