一、定时任务重叠执行的痛点

上周，一位做电商系统的朋友向我求助：他们的库存同步任务出现了数据错乱的问题。

"我们的库存同步任务每5分钟执行一次，"朋友焦急地说，"但有时候任务执行时间超过5分钟，导致上一轮还没结束，下一轮就开始了，结果库存数据被重复处理，出现了负数。"

我查看了他们的代码，发现问题确实很严重：

• 使用 @Scheduled 注解实现定时任务
• 任务执行时间不确定，有时超过定时周期
• 没有任何防重叠措施
• 并发执行导致数据竞争和不一致
• 任务堆积导致系统负载飙升

更关键的是，他们根本不知道有多少次任务发生了重叠，也没有任何监控和告警机制。

二、传统方案的局限性

1. 增加定时周期

通过延长定时周期来避免任务重叠。

@Scheduled(cron = "0 */10 * * * ?") // 从5分钟改为10分钟
public void syncInventory() {
    // 库存同步逻辑
}

这种方案的问题：

• 业务延迟：任务执行间隔变长，可能影响业务时效性
• 治标不治本：如果任务执行时间超过新的周期，仍然会重叠
• 资源浪费：当任务执行时间很短时，会有大量空闲时间
• 不够灵活：无法根据任务实际执行情况动态调整

2. 使用 synchronized 同步

在任务方法上添加 synchronized 关键字。

@Scheduled(cron = "0 */5 * * * ?")
public synchronized void syncInventory() {
    // 库存同步逻辑
}

这种方案的问题：

• 阻塞其他任务：所有定时任务共享同一个锁，可能阻塞其他任务
• 无法控制跳过策略：只能等待前一个任务完成，不能选择跳过
• 死锁风险：如果任务中调用其他同步方法，可能导致死锁
• 无法监控：无法知道有多少次任务被阻塞

3. 使用 ReentrantLock

使用可重入锁来控制任务执行。

private final ReentrantLock lock = new ReentrantLock();

@Scheduled(cron = "0 */5 * * * ?")
public void syncInventory() {
    if (!lock.tryLock()) {
        return; // 跳过
    }
    try {
        // 库存同步逻辑
    } finally {
        lock.unlock();
    }
}

这种方案的问题：

• 代码重复：每个任务都需要重复添加锁逻辑
• 管理复杂：多个任务需要多个锁，管理复杂
• 无法统一监控：无法统一监控所有任务的执行状态
• 异常处理：需要手动处理异常和解锁

4. 使用信号量

使用信号量来控制并发执行。

private final Semaphore semaphore = new Semaphore(1);

@Scheduled(cron = "0 */5 * * * ?")
public void syncInventory() {
    if (!semaphore.tryAcquire()) {
        return; // 跳过
    }
    try {
        // 库存同步逻辑
    } finally {
        semaphore.release();
    }
}

这种方案的问题：

• 与 ReentrantLock 类似：同样存在代码重复和管理复杂的问题
• 无法区分任务：不同任务需要不同的信号量
• 无法统一配置：无法统一配置跳过策略
• 监控困难：无法统一监控所有任务的状态

三、终极方案：自定义防重叠注解 + 任务状态管理

今天，我要和大家分享一个在实战中验证过的解决方案：自定义防重叠注解 + 任务状态管理。

这套方案的核心思想是：

1. 自定义注解：创建一个 @PreventOverlap 注解，标记需要防重叠的定时任务
2. AOP 切面：通过 AOP 拦截被注解标记的方法，实现防重叠逻辑
3. 任务状态管理：维护任务的执行状态，支持不同的防重叠策略
4. 统一监控：统一监控所有任务的执行状态和重叠情况
5. 灵活配置：支持自定义跳过策略、超时时间等参数

四、方案详解

1. 核心原理

防重叠执行的工作流程如下：

定时任务触发
    ↓
AOP 切面拦截
    ↓
检查任务是否正在执行
    ↓
是 → 根据策略处理（跳过/等待）
否 → 标记任务为执行中
    ↓
执行任务逻辑
    ↓
标记任务为执行完成
    ↓
返回结果

2. SpringBoot实现

（1）防重叠注解

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface PreventOverlap {
    /**
     * 任务名称，默认为方法名
     */
    String value() default "";

    /**
     * 防重叠策略
     */
    OverlapStrategy strategy() default OverlapStrategy.SKIP;

    /**
     * 最大等待时间（毫秒），仅当策略为 WAIT 时有效
     */
    long maxWaitTime() default 0;

    /**
     * 是否记录重叠事件
     */
    boolean recordOverlap() default true;

    /**
     * 执行超时时间（毫秒），0表示不设置
     */
    long timeout() default 0;
}

（2）防重叠策略枚举

public enum OverlapStrategy {
    /**
     * 跳过：如果任务正在执行，则跳过本次执行
     */
    SKIP,

    /**
     * 等待：如果任务正在执行，则等待其完成
     */
    WAIT,

    /**
     * 强制：强制终止正在执行的任务，执行新任务
     */
    FORCE
}

（3）任务状态管理器

@Component
public class TaskStatusManager {

    private final ConcurrentMap<String, TaskStatus> taskStatusMap = new ConcurrentHashMap<>();

    public boolean tryAcquire(String taskName) {
        TaskStatus current = taskStatusMap.get(taskName);
        if (current != null && current.isRunning()) {
            return false;
        }
        taskStatusMap.put(taskName, new TaskStatus(true, System.currentTimeMillis()));
        return true;
    }

    public boolean tryAcquireWithWait(String taskName, long maxWaitTime) {
        long startTime = System.currentTimeMillis();
        while (System.currentTimeMillis() - startTime < maxWaitTime) {
            if (tryAcquire(taskName)) {
                return true;
            }
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                return false;
            }
        }
        return false;
    }

    public void release(String taskName) {
        TaskStatus status = taskStatusMap.get(taskName);
        if (status != null) {
            status.setRunning(false);
            status.setEndTime(System.currentTimeMillis());
        }
    }

    public boolean isRunning(String taskName) {
        TaskStatus status = taskStatusMap.get(taskName);
        return status != null && status.isRunning();
    }

    public TaskStatus getStatus(String taskName) {
        return taskStatusMap.get(taskName);
    }

    public Map<String, TaskStatus> getAllStatus() {
        return new HashMap<>(taskStatusMap);
    }

    @Data
    public static class TaskStatus {
        private boolean running;
        private long startTime;
        private long endTime;
        private long duration;

        public TaskStatus(boolean running, long startTime) {
            this.running = running;
            this.startTime = startTime;
        }

        public void setEndTime(long endTime) {
            this.endTime = endTime;
            this.duration = endTime - startTime;
        }
    }
}

（4）防重叠切面

@Aspect
@Component
@Slf4j
public class PreventOverlapAspect {

    @Autowired
    private TaskStatusManager taskStatusManager;

    @Autowired
    private TaskOverlapRecordService recordService;

    @Around("@annotation(preventOverlap)")
    public Object around(ProceedingJoinPoint joinPoint, PreventOverlap preventOverlap) throws Throwable {
        String taskName = getTaskName(joinPoint, preventOverlap);
        OverlapStrategy strategy = preventOverlap.strategy();
        long maxWaitTime = preventOverlap.maxWaitTime();
        boolean recordOverlap = preventOverlap.recordOverlap();
        long timeout = preventOverlap.timeout();

        boolean acquired = false;
        switch (strategy) {
            case SKIP:
                acquired = taskStatusManager.tryAcquire(taskName);
                if (!acquired) {
                    if (recordOverlap) {
                        recordService.recordOverlap(taskName, "Task skipped due to overlap");
                    }
                    log.warn("Task {} skipped: already running", taskName);
                    return null;
                }
                break;
            case WAIT:
                acquired = taskStatusManager.tryAcquireWithWait(taskName, maxWaitTime);
                if (!acquired) {
                    if (recordOverlap) {
                        recordService.recordOverlap(taskName, "Task skipped due to wait timeout");
                    }
                    log.warn("Task {} skipped: wait timeout", taskName);
                    return null;
                }
                break;
            case FORCE:
                taskStatusManager.release(taskName);
                acquired = taskStatusManager.tryAcquire(taskName);
                if (recordOverlap) {
                    recordService.recordOverlap(taskName, "Forced to stop previous execution");
                }
                log.warn("Task {} forced: stopped previous execution", taskName);
                break;
        }

        if (!acquired) {
            return null;
        }

        long startTime = System.currentTimeMillis();
        Object result = null;
        try {
            if (timeout > 0) {
                result = executeWithTimeout(joinPoint, timeout);
            } else {
                result = joinPoint.proceed();
            }
        } catch (Exception e) {
            log.error("Task {} execution error", taskName, e);
            throw e;
        } finally {
            taskStatusManager.release(taskName);
            long duration = System.currentTimeMillis() - startTime;
            log.info("Task {} completed in {}ms", taskName, duration);
        }

        return result;
    }

    private String getTaskName(ProceedingJoinPoint joinPoint, PreventOverlap preventOverlap) {
        String value = preventOverlap.value();
        if (!value.isEmpty()) {
            return value;
        }
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        return signature.getMethod().getName();
    }

    private Object executeWithTimeout(ProceedingJoinPoint joinPoint, long timeout) throws Throwable {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        Future<Object> future = executor.submit(() -> {
            try {
                return joinPoint.proceed();
            } catch (Throwable e) {
                throw new RuntimeException(e);
            }
        });

        try {
            return future.get(timeout, TimeUnit.MILLISECONDS);
        } catch (TimeoutException e) {
            future.cancel(true);
            throw new RuntimeException("Task execution timeout", e);
        } finally {
            executor.shutdownNow();
        }
    }
}

（5）重叠记录服务

@Service
@Slf4j
public class TaskOverlapRecordService {

    private final List<TaskOverlapRecord> overlapRecords = new CopyOnWriteArrayList<>();

    public void recordOverlap(String taskName, String reason) {
        TaskOverlapRecord record = new TaskOverlapRecord();
        record.setTaskName(taskName);
        record.setReason(reason);
        record.setTimestamp(System.currentTimeMillis());
        overlapRecords.add(record);

        if (overlapRecords.size() > 1000) {
            overlapRecords.removeIf(r -> r.getTimestamp() < System.currentTimeMillis() - 24 * 60 * 60 * 1000);
        }

        log.info("Task overlap recorded: {} - {}", taskName, reason);
    }

    public List<TaskOverlapRecord> getRecentOverlaps(int limit) {
        return overlapRecords.stream()
                .sorted(Comparator.comparingLong(TaskOverlapRecord::getTimestamp).reversed())
                .limit(limit)
                .collect(Collectors.toList());
    }

    public long getOverlapCount(String taskName) {
        return overlapRecords.stream()
                .filter(r -> r.getTaskName().equals(taskName))
                .count();
    }

    public long getOverlapCountInLastHour() {
        long oneHourAgo = System.currentTimeMillis() - 60 * 60 * 1000;
        return overlapRecords.stream()
                .filter(r -> r.getTimestamp() >= oneHourAgo)
                .count();
    }

    @Data
    public static class TaskOverlapRecord {
        private String taskName;
        private String reason;
        private long timestamp;
    }
}

（6）使用示例

@Service
public class InventorySyncService {

    @PreventOverlap(value = "syncInventory", strategy = OverlapStrategy.SKIP)
    @Scheduled(cron = "0 */5 * * * ?")
    public void syncInventory() {
        // 模拟长时间执行
        try {
            Thread.sleep(7 * 60 * 1000); // 7分钟
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        log.info("Inventory sync completed");
    }

    @PreventOverlap(value = "backupData", strategy = OverlapStrategy.WAIT, maxWaitTime = 30000)
    @Scheduled(cron = "0 */10 * * * ?")
    public void backupData() {
        try {
            Thread.sleep(3 * 60 * 1000); // 3分钟
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        log.info("Data backup completed");
    }

    @PreventOverlap(value = "cleanCache", strategy = OverlapStrategy.FORCE, timeout = 60000)
    @Scheduled(cron = "0 */1 * * * ?")
    public void cleanCache() {
        try {
            Thread.sleep(90 * 1000); // 1分30秒
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        log.info("Cache cleaned");
    }
}

（7）监控控制器

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

    @Autowired
    private TaskStatusManager taskStatusManager;

    @Autowired
    private TaskOverlapRecordService overlapRecordService;

    @GetMapping("/status")
    public ResponseEntity<Map<String, TaskStatusManager.TaskStatus>> getTaskStatus() {
        Map<String, TaskStatusManager.TaskStatus> statusMap = taskStatusManager.getAllStatus();
        return ResponseEntity.ok(statusMap);
    }

    @GetMapping("/overlaps")
    public ResponseEntity<List<TaskOverlapRecordService.TaskOverlapRecord>> getOverlaps(
            @RequestParam(defaultValue = "50") int limit) {
        List<TaskOverlapRecordService.TaskOverlapRecord> overlaps = overlapRecordService.getRecentOverlaps(limit);
        return ResponseEntity.ok(overlaps);
    }

    @GetMapping("/overlap-count")
    public ResponseEntity<Map<String, Long>> getOverlapCount(
            @RequestParam(required = false) String taskName) {
        Map<String, Long> result = new HashMap<>();
        if (taskName != null) {
            result.put(taskName, overlapRecordService.getOverlapCount(taskName));
        } else {
            result.put("total", overlapRecordService.getOverlapCountInLastHour());
        }
        return ResponseEntity.ok(result);
    }

    @GetMapping("/health")
    public ResponseEntity<Map<String, Object>> health() {
        Map<String, Object> health = new HashMap<>();
        health.put("status", "UP");
        health.put("taskCount", taskStatusManager.getAllStatus().size());
        health.put("recentOverlaps", overlapRecordService.getOverlapCountInLastHour());
        return ResponseEntity.ok(health);
    }
}

3. 配置类

@Configuration
@EnableScheduling
public class TaskConfig {

    @Bean
    public TaskStatusManager taskStatusManager() {
        return new TaskStatusManager();
    }

    @Bean
    public TaskOverlapRecordService taskOverlapRecordService() {
        return new TaskOverlapRecordService();
    }

    @Bean
    public PreventOverlapAspect preventOverlapAspect() {
        return new PreventOverlapAspect();
    }
}

五、性能对比

1. 测试场景

• 定时任务周期：5分钟
• 任务执行时间：7分钟（超过周期）
• 测试时间：1小时
• 测试策略：SKIP、WAIT、FORCE、无防护

2. 测试结果

六、最佳实践

1. 策略选择

• SKIP：适用于实时性要求不高，任务可以安全跳过的场景
• WAIT：适用于任务必须执行，且执行时间不会太长的场景
• FORCE：适用于任务执行时间过长，需要强制更新的场景

2. 任务设计

• 合理拆分：将长时间运行的任务拆分为多个短时间任务
• 超时设置：为任务设置合理的超时时间，避免任务无限执行
• 异常处理：在任务中妥善处理异常，确保任务能够正常完成
• 日志记录：详细记录任务执行日志，便于排查问题

3. 监控告警

• 监控任务状态：实时监控任务的执行状态和重叠情况
• 设置告警阈值：当重叠次数超过阈值时发送告警
• 定期巡检：定期检查任务执行情况，优化任务设计
• 性能监控：监控任务执行时间和系统负载

4. 配置优化

• 合理设置定时周期：根据任务执行时间合理设置定时周期
• 使用合理的策略：根据业务需求选择合适的防重叠策略
• 设置合理的等待时间：对于 WAIT 策略，设置合理的最大等待时间
• 设置超时时间：为任务设置合理的超时时间

七、总结与展望

方案总结

1. 简单易用：通过注解方式，一行代码即可实现防重叠
2. 灵活配置：支持多种防重叠策略，满足不同业务需求
3. 统一管理：统一管理所有任务的执行状态
4. 监控完善：提供详细的监控指标和重叠记录
5. 性能优秀：对系统性能影响小，处理效率高
6. 可扩展性强：易于扩展，支持自定义策略和监控

未来优化方向

1. 分布式支持：支持分布式环境下的任务防重叠
2. 动态调整：根据任务执行情况动态调整防重叠策略
3. 可视化界面：提供Web界面，直观展示任务执行情况
4. 智能预测：根据历史执行时间预测任务执行时间，优化调度
5. 任务依赖：支持任务之间的依赖关系管理

技术价值

1. 保证数据一致性：避免任务重叠导致的数据竞争和不一致
2. 提高系统稳定性：减少任务堆积和系统负载
3. 提升用户体验：确保任务执行的可靠性和可预测性
4. 便于问题排查：详细的监控和日志记录，便于问题排查
5. 降低维护成本：统一的防重叠机制，减少代码重复和维护成本

八、写在最后

定时任务重叠执行是一个常见的问题，但通过自定义防重叠注解 + 任务状态管理方案，我们可以在保证任务执行可靠性的同时，提供灵活的防重叠策略和完善的监控机制。

当然，这套方案也不是银弹，它有以下局限性：

• 仅适用于单机环境：在分布式环境下需要额外的分布式锁支持
• 增加系统复杂度：需要维护任务状态和监控机制
• 可能影响实时性：SKIP 策略可能导致任务延迟执行

但对于单机环境下的定时任务，这套方案已经足够解决问题，而且稳定可靠。

希望这篇文章能给你带来一些启发，帮助你在实际项目中更好地处理定时任务的重叠执行问题。

如果你在使用这套方案的过程中有其他经验或困惑，欢迎在评论区留言交流！

服务端技术精选，专注分享后端开发实战经验，让技术落地更简单。

如果你觉得这篇文章有用，欢迎点赞、在看、分享三连！