Java 后端 / 系统课时
实现可控定时任务
实现可控定时任务
本课将实现一个可在多实例环境安全运行的周期任务:使用外部化 Cron 与明确时区触发,通过数据库租约锁选出唯一执行者,并用独立工作线程、超时取消和日志验证控制任务边界。
学习目标
- 正确选择
cron、fixedDelay与fixedRate,并显式指定业务时区。 - 使用数据库租约锁避免多个应用实例同时执行同一任务。
- 为任务设置执行超时、释放锁规则和可验证的运行日志。
选择触发方式与时区
@Scheduled 提供三类常用触发方式,它们表达的业务语义不同。
| 方式 | 下一次触发基准 | 适用场景 |
|---|---|---|
cron |
日历时间 | 对账、结算、报表等固定时点任务 |
fixedDelay |
上一次执行结束 | 不允许连续追赶的轮询任务 |
fixedRate |
上一次计划开始时间 | 采样、刷新等强调频率的短任务 |
日历任务应始终填写 zone,不要依赖服务器默认时区。存在夏令时的地区可能出现某个本地时间被跳过或重复,关键账务任务应在需求中明确补跑与去重规则。
建立数据库租约锁
多实例部署时,每个实例都会收到相同的调度触发。下面使用 MySQL 建立一行租约记录,通过原子 UPDATE 竞争锁。所有时间都由数据库的 UTC 时钟生成,避免应用节点时钟不一致。
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
);预期结果
scheduled_lock 表创建成功,并且 settlement-close 只有一条锁记录;重复执行脚本不会插入重复主键。租约锁不是永久互斥锁。实例拿锁时把 locked_until 推到未来;正常结束后主动释放。实例崩溃时不需要人工解锁,租约到期后其他实例可以重新竞争。

配置调度器
把 Cron 与时区放在配置文件中,便于不同环境独立调整。调度线程只负责触发和等待结果,真正的业务逻辑由独立工作线程执行。
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 秒,因此即使任务失控,也为取消与释放留出了安全余量。
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);
}
}
}预期结果
应用启动后会按配置的 Cron 注册任务;每次触发只有成功更新租约记录的实例执行 closeSettlement,任务超过 30 秒会被取消并记录超时。分别启动两个连接同一数据库的实例:
SERVER_PORT=8081 ./mvnw spring-boot:run
SERVER_PORT=8082 ./mvnw spring-boot:run预期输出
<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 秒租约到期后另一实例能够接管。
- 重复触发相同业务批次,确认业务数据不会被重复结算。