多容器环境下Spring Session JDBC过期清理Cron优化问题咨询

针对K8S多实例同时清理MySQL中Spring Session导致的锁表问题，以下是几个可落地的高性能解决方案：

方案一：基于MySQL分布式锁实现单实例独占清理 #

利用MySQL原生的GET_LOCK机制实现分布式锁，确保同一时间只有一个实例执行清理逻辑，彻底避免锁竞争：

1. 先禁用默认的自动清理调度：

   spring.session.jdbc.cleanup-cron= # 留空关闭内置调度
   

2. 自定义定时清理组件：

   @Component
   public class SessionCleanupTask {
       private final JdbcTemplate jdbcTemplate;
       private static final String LOCK_KEY = "spring_session_clean_lock";
       private static final String BATCH_DELETE_SQL = "DELETE FROM SPRING_SESSION WHERE EXPIRY_TIME < ? LIMIT 1000";
   
       public SessionCleanupTask(JdbcTemplate jdbcTemplate) {
           this.jdbcTemplate = jdbcTemplate;
       }
   
       @Scheduled(cron = "0 0 * * * ?") // 自定义执行周期，比如每小时一次
       public void cleanExpiredSessions() {
           // 尝试获取锁，超时时间0表示立即返回结果，不等待
           Boolean lockAcquired = jdbcTemplate.queryForObject(
               "SELECT GET_LOCK(?, 0)",
               Boolean.class,
               LOCK_KEY
           );
   
           if (Boolean.TRUE.equals(lockAcquired)) {
               try {
                   int deletedRows;
                   // 分批删除，避免一次性锁大量行
                   do {
                       deletedRows = jdbcTemplate.update(
                           BATCH_DELETE_SQL,
                           System.currentTimeMillis()
                       );
                   } while (deletedRows > 0);
               } finally {
                   // 无论清理成功与否，最终释放锁
                   jdbcTemplate.execute("SELECT RELEASE_LOCK('" + LOCK_KEY + "')");
               }
           }
       }
   }
   

   注：MySQL的GET_LOCK是会话级锁，实例宕机后连接断开会自动释放锁，无需担心死锁。

方案二：用K8S CronJob独立执行清理 #

把清理逻辑从应用实例中剥离，用K8S CronJob单独部署轻量任务，彻底隔离清理操作与业务服务：

1. 禁用应用内的清理调度：

   spring.session.jdbc.cleanup-cron=
   

2. 编写Shell清理脚本（session-cleanup.sh）：

   #!/bin/bash
   mysql -h "${DB_HOST}" -u "${DB_USER}" -p"${DB_PASSWORD}" "${DB_NAME}" -e "
       WHILE TRUE DO
           DELETE FROM SPRING_SESSION WHERE EXPIRY_TIME < UNIX_TIMESTAMP()*1000 LIMIT 1000;
           IF ROW_COUNT() = 0 THEN LEAVE; END IF;
       END WHILE;
   "
   

3. 部署K8S CronJob示例YAML：

   apiVersion: batch/v1
   kind: CronJob
   metadata:
     name: spring-session-cleanup
   spec:
     schedule: "0 0 * * *" # 每小时执行一次
     jobTemplate:
       spec:
         template:
           spec:
             containers:
             - name: mysql-client
               image: mysql:8.0
               command: ["/bin/sh", "-c"]
               args: ["/scripts/session-cleanup.sh"]
               env:
               - name: DB_HOST
                 value: "your-mysql-service-name"
               - name: DB_USER
                 valueFrom:
                   secretKeyRef:
                     name: mysql-secrets
                     key: username
               - name: DB_PASSWORD
                 valueFrom:
                   secretKeyRef:
                     name: mysql-secrets
                     key: password
               - name: DB_NAME
                 value: "your-database-name"
               volumeMounts:
               - name: cleanup-scripts
                 mountPath: /scripts
             volumes:
             - name: cleanup-scripts
               configMap:
                 name: session-cleanup-config
             restartPolicy: OnFailure
   

方案三：优化清理语句降低锁冲突（最小改动） #

如果不想调整部署架构，可通过优化清理语句减少锁范围，降低多实例竞争的影响：

1. 自定义SessionRepository的清理SQL，实现分批删除：

   @Configuration
   public class SessionConfig {
       @Bean
       public JdbcSessionRepositoryCustomizer sessionRepositoryCustomizer() {
           return repository -> {
               // 替换默认清理SQL为分批删除
               repository.setCleanupSql("DELETE FROM SPRING_SESSION WHERE EXPIRY_TIME < ? LIMIT 1000");
           };
       }
   }
   

2. 给EXPIRY_TIME字段添加索引，加速查询并减少锁持有时间：

   CREATE INDEX idx_spring_session_expiry ON SPRING_SESSION(EXPIRY_TIME);
   

   即使多实例同时执行，每次仅删除少量数据，锁的行数少、持有时间短，能大幅降低锁冲突概率。

方案四：切换到Redis存储会话（长期最优解） #

如果架构允许，将Spring Session的存储从MySQL切换到Redis：

• Redis原生支持键自动过期，无需手动清理过期会话，从根源上避免锁表问题。
• 配置简单，只需引入Redis依赖并修改配置：

  spring.session.store-type=redis
  spring.redis.host=your-redis-service
  spring.redis.port=6379
  

  Redis的分布式会话性能优于JDBC，更适配K8S多实例集群场景。

内容的提问来源于stack exchange，提问作者Michael Bourak