多Pod部署Spring Boot应用避免重复读取数据库行的方案咨询

方案1：数据库行级悲观锁（高并发场景推荐） #

直接利用数据库行锁机制，让每个Pod仅能获取未被锁定的数据行。核心是使用SELECT ... FOR UPDATE SKIP LOCKED语法（MySQL 8.0+、PostgreSQL 9.5+支持），查询时锁定符合条件的行，同时跳过已被其他事务锁定的行，从根源上避免重复读取。

实现示例 #

用JPA执行原生SQL查询：

@Repository
public interface TaskRepository extends JpaRepository<Task, Long> {
    @Query(value = "SELECT * FROM task WHERE status = 'PENDING' LIMIT 5 FOR UPDATE SKIP LOCKED", nativeQuery = true)
    List<Task> findPendingTasksForLock();
}

调度逻辑中结合事务使用：

@Scheduled(cron = "0 */5 * * * ?")
@Transactional
public void processTasks() {
    List<Task> tasks = taskRepository.findPendingTasksForLock();
    for (Task task : tasks) {
        // 执行任务处理逻辑
        task.setStatus("COMPLETED");
        taskRepository.save(task);
    }
}

注意：必须在事务范围内执行查询和处理，事务提交后自动释放锁；SKIP LOCKED会跳过已锁定行，不会让Pod等待，适合调度器批量处理场景。

方案2：状态标记+乐观锁 #

给数据行增加状态字段（如status：PENDING/PROCESSING/COMPLETED）和版本号字段（version），通过“查询-更新”的原子性操作确保只有一个Pod能抢占任务。

实现步骤 #

1. 实体类添加状态和版本字段：

@Entity
public class Task {
    @Id
    private Long id;
    private String status;
    @Version // JPA乐观锁注解，自动维护版本号
    private Integer version;
    // 其他字段、getter/setter
}

2. 编写抢占并处理任务的逻辑：

@Service
public class TaskService {
    @Autowired
    private TaskRepository taskRepository;

    @Transactional
    public void processPendingTasks() {
        List<Task> pendingTasks = taskRepository.findByStatus("PENDING");
        for (Task task : pendingTasks) {
            try {
                // 尝试更新状态为PROCESSING，乐观锁自动校验版本号
                task.setStatus("PROCESSING");
                taskRepository.save(task);
                // 执行任务处理逻辑
                handleTask(task);
                // 处理完成后更新状态为COMPLETED
                task.setStatus("COMPLETED");
                taskRepository.save(task);
            } catch (OptimisticLockingFailureException e) {
                // 版本号不匹配，说明被其他Pod抢占，跳过该任务
                continue;
            }
        }
    }
}

注意：该方式适合并发量不极高的场景，若并发过高，会出现较多乐观锁失败情况，需结合批量操作优化。

方案3：分布式锁（基于Redis/数据库） #

借助分布式锁，确保同一任务只能被一个Pod获取并处理。比如用Redis的Redisson实现可重入锁，或者用数据库唯一键做锁。

Redis分布式锁示例（Redisson） #

配置Redisson客户端后，编写调度逻辑：

@Autowired
private RedissonClient redissonClient;
@Autowired
private TaskRepository taskRepository;

@Scheduled(cron = "0 */5 * * * ?")
public void processTasks() {
    List<Task> pendingTasks = taskRepository.findByStatus("PENDING");
    for (Task task : pendingTasks) {
        RLock lock = redissonClient.getLock("task-lock:" + task.getId());
        try {
            // 尝试获取锁：等待1秒，锁自动过期30秒（防止Pod挂了锁不释放）
            if (lock.tryLock(1, 30, TimeUnit.SECONDS)) {
                // 二次校验状态，避免其他Pod已处理
                Task latestTask = taskRepository.findById(task.getId()).orElse(null);
                if (latestTask != null && "PENDING".equals(latestTask.getStatus())) {
                    handleTask(latestTask);
                    latestTask.setStatus("COMPLETED");
                    taskRepository.save(latestTask);
                }
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } finally {
            if (lock.isHeldByCurrentThread()) {
                lock.unlock();
            }
        }
    }
}

注意：必须加二次状态校验，因为获取锁前的查询和加锁之间可能有其他Pod修改了状态；锁过期时间要大于任务处理的最长时间，避免任务未完成锁就释放。

方案4：替换为分布式任务调度框架 #

放弃自研Cron Job，改用成熟的分布式任务调度框架（如XXL-Job、Elastic-Job），这些框架内置任务分片、负载均衡和唯一执行机制，无需自行处理锁逻辑。

实现思路 #

1. 将原有任务逻辑封装成JobHandler；
2. 在调度中心配置任务的Cron表达式和分片规则；
3. 多个Pod作为执行器注册到调度中心，框架会自动将任务分配给不同执行器，确保同一任务分片仅被一个Pod处理。

该方式适合长期维护的项目，能减少自研锁逻辑的复杂度和潜在Bug。

内容的提问来源于stack exchange，提问作者arpit aggarwal