┌─────────────────────────────────────────────────────────────────┐
│                   分布式系统核心挑战                             │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  1. 定时任务重复执行  → 多实例同时触发同一任务                   │
│  2. 并发控制          → 多个服务同时修改同一资源                 │
│  3. 数据一致性        → 分布式事务、最终一致性                   │
│  4. 服务治理          → 服务发现、负载均衡、熔断降级             │
│  5. 缓存一致性        → 缓存穿透、击穿、雪崩                     │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

┌────────────────────────────────────────────────────────────┐
│  问题：三个实例同时触发同一任务                             │
├────────────────────────────────────────────────────────────┤
│                                                            │
│  实例A  @Scheduled(cron="0 0 2 * * ?")  ────┐            │
│  实例B  @Scheduled(cron="0 0 2 * * ?")  ────┼──> 重复执行！
│  实例C  @Scheduled(cron="0 0 2 * * ?")  ────┘            │
│                                                            │
└────────────────────────────────────────────────────────────┘

问题：你的定时任务需要哪种方案？

START
  │
  ├─ 是否有多个定时任务（>10个）？
  │   ├─ 是 → 使用 XXL-Job 或 Elastic Job
  │   └─ 否 → 继续判断
  │
  ├─ 任务是否涉及数据库写操作？
  │   ├─ 是 → 数据库唯一约束（最简单）
  │   └─ 否 → 继续判断
  │
  ├─ 是否已有 Redis 集群？
  │   ├─ 是 → Redis 分布式锁（Redisson）
  │   └─ 否 → 继续判断
  │
  ├─ 是否是金融级强一致性场景？
  │   ├─ 是 → ZooKeeper 锁
  │   └─ 否 → 数据库唯一约束
  │
  └─ END

@Service
@RequiredArgsConstructor
public class ScheduledTaskService {

    private final RedissonClient redissonClient;

    @Scheduled(cron = "0 */5 * * * ?")
    public void syncDataTask() {
        String lockKey = "task:sync:data";
        RLock lock = redissonClient.getLock(lockKey);

        try {
            // 尝试加锁：不等待，锁10分钟自动释放
            boolean acquired = lock.tryLock(0, 10, TimeUnit.MINUTES);

            if (!acquired) {
                log.info("任务已在其他实例执行，跳过");
                return;
            }

            try {
                // 执行任务
                doSyncData();
            } finally {
                lock.unlock();
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            log.error("任务执行被中断", e);
        }
    }
}

spring:
  redis:
    redisson:
      config: |
        singleServerConfig:
          address: "redis://localhost:6379"
          connectionPoolSize: 64

@Service
@RequiredArgsConstructor
public class ScheduledTaskService {

    private final TaskRecordMapper taskRecordMapper;

    @Scheduled(cron = "0 0 2 * * ?")
    public void dailyReport() {
        String taskId = "daily-report-" + LocalDate.now();

        try {
            // 插入任务记录（唯一索引保证幂等）
            TaskRecord record = new TaskRecord();
            record.setTaskId(taskId);
            record.setCreateTime(LocalDateTime.now());
            taskRecordMapper.insert(record);

            // 执行任务
            doDailyReport();

        } catch (DuplicateKeyException e) {
            log.info("任务已在其他实例执行: {}", taskId);
        }
    }
}

CREATE TABLE task_record (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    task_id VARCHAR(128) NOT NULL UNIQUE COMMENT '任务ID',
    status VARCHAR(32) DEFAULT 'SUCCESS',
    create_time DATETIME DEFAULT CURRENT_TIMESTAMP,
    INDEX idx_create_time (create_time)
) COMMENT='定时任务执行记录';

┌────────────────────────────────────────────────────────────┐
│              XXL-Job 核心能力                              │
├────────────────────────────────────────────────────────────┤
│  ✅ 调度层面避免重复（自动选主）                           │
│  ✅ 可视化管理界面                                          │
│  ✅ 任务依赖、失败重试、邮件告警                            │
│  ✅ 支持任务分片（大数据处理）                              │
│  ✅ 路由策略（第一个、轮询、随机等）                        │
│  ✅ 执行日志实时查看                                        │
└────────────────────────────────────────────────────────────┘

<!-- pom.xml -->
<dependency>
    <groupId>com.xuxueli</groupId>
    <artifactId>xxl-job-core</artifactId>
    <version>2.4.0</version>
</dependency>

@Component
public class SampleXxlJob {

    @XxlJob("syncDataJob")
    public void syncData() {
        XxlJobHelper.log("任务开始执行");

        try {
            // 任务逻辑
            doSyncData();

            XxlJobHelper.handleSuccess();
        } catch (Exception e) {
            XxlJobHelper.handleFailure("任务执行失败: " + e.getMessage());
        }
    }
}

// ❌ 错误：锁超时太短
lock.tryLock(0, 5, TimeUnit.SECONDS);  // 任务执行10秒，锁5秒就释放

// ✅ 正确：根据任务执行时间设置
lock.tryLock(0, 30, TimeUnit.MINUTES);  // 预留足够时间

// ❌ 错误：未处理 InterruptedException
try {
    if (lock.tryLock(0, 10, TimeUnit.SECONDS)) {
        lock.unlock();
    }
} catch (InterruptedException e) {
    // 什么都不做
}

// ✅ 正确：恢复中断状态
} catch (InterruptedException e) {
    Thread.currentThread().interrupt();
    log.error("任务被中断", e);
}

// ❌ 错误：异常时未释放锁
if (lock.tryLock()) {
    doTask();  // 如果抛异常，锁永远不会释放
    lock.unlock();
}

// ✅ 正确：使用 try-finally
if (lock.tryLock()) {
    try {
        doTask();
    } finally {
        lock.unlock();
    }
}

-- ❌ 错误：只有 task_id 唯一索引
CREATE TABLE task_record (
    id BIGINT PRIMARY KEY,
    task_id VARCHAR(64) UNIQUE  -- 可能重复
);

-- ✅ 正确：增加日期维度
CREATE TABLE task_record (
    id BIGINT PRIMARY KEY,
    task_date DATE NOT NULL,
    task_id VARCHAR(64) NOT NULL,
    UNIQUE KEY uk_task (task_date, task_id)  -- 复合唯一键
);

// ✅ 推荐：增加任务执行时间监控
@Scheduled(cron = "0 */5 * * * ?")
public void taskWithMetrics() {
    long startTime = System.currentTimeMillis();

    try {
        doTask();

        long duration = System.currentTimeMillis() - startTime;
        log.info("任务执行成功，耗时: {}ms", duration);

        if (duration > 60000) {
            log.warn("任务执行时间超过1分钟，可能需要优化");
        }
    } catch (Exception e) {
        log.error("任务执行失败，耗时: {}ms",
            System.currentTimeMillis() - startTime, e);
        throw e;
    }
}