集群环境下多节点分布式定时任务数据库乐观锁

背景

• Spring Task并不是为分布式环境设计的，在分布式环境下，这种定时任务是不支持集群配置的，如果部署到多个节点上，各个节点之间并没有任何协调通讯机制，因为集群的节点之间是不会共享任务信息的，每个节点上的任务都会按时执行。

解决方案

• 我们选择了用数据库+乐观锁的方式来解决任务互斥访问的问题。大致的思路是这样的，声明一把全局的“锁”作为互斥量，哪个应用服务器拿到这把“锁”，就有执行任务的权利，未拿到“锁”的应用服务器不进行任何任务相关的操作。

java + mongodb数据库实现

• 定时任务锁对象

package com.kbao.kbcassist.job.entity;

import lombok.Data;
import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.index.Indexed;
import org.springframework.data.mongodb.core.mapping.Document;

import java.time.LocalDateTime;

/**
 * @className: JobLocksMo
 * @description: 定时任务锁对象
 * @author: wangzb01
 * @version: V1.0
 * @since: V1.0
 * @className: 2021-01-29 11:01
 */
@Data
@Document
public class JobLocksMo {

    /**
     * 主键ID
     */
    @Id
    private String id;

    /**
     * job名称
     */
    private String name;

    /**
     * job状态：0-空闲，1-运行
     */
    private Integer status;

    /**
     * job描述
     */
    private String description;

    /**
     * 版本
     */
    @Indexed(background = true)
    private Long version;

    /**
     * 创建ID
     */
    private String createId;

    /**
     * 创建时间
     */
    private LocalDateTime createTime;

    /**
     * 更新ID
     */
    private String updateId;

    /**
     * 更新时间
     */
    private LocalDateTime updateTime;


}

• 定时任务锁DAO

package com.kbao.kbcassist.common.dao;

import com.kbao.kbcassist.job.entity.JobLocksMo;

/**
 * @className: JobLocksMongoDao
 * @description: 定时任务锁DAO
 * @author: wangzb01
 * @version: V1.0
 * @since: V1.0
 * @className: 2021-01-29 11:04
 */
public interface JobLocksMongoDao {

    /**
     * @description 新增
     * @author wangzb01
     * @date 2021-01-29 11:18
     * @param jobLocksMo
     * @return void
     */
    void save(JobLocksMo jobLocksMo);

    /**
     * @description 主键查询
     * @author wangzb01
     * @date 2021-01-29 11:20
     * @param id
     * @return com.kbao.kbcassist.job.entity.JobLocksMo
     */
    JobLocksMo findById(String id);

    /**
     * @description 根据任务ID和当前版本_加锁
     * @author wangzb01
     * @date 2021-01-29 14:11
     * @param id
     * @param version
     * @return com.kbao.kbcassist.job.entity.JobLocksMo
     */
    JobLocksMo lock(String id, Long version);

    /**
     * @description 根据任务ID_释放锁
     * @author wangzb01
     * @date 2021-01-29 14:10
     * @param id
     * @return com.kbao.kbcassist.job.entity.JobLocksMo
     */
    JobLocksMo unlock(String id);

}

• 定时任务锁DAO实现

package com.kbao.kbcassist.common.dao.impl;

import com.kbao.kbcassist.common.dao.JobLocksMongoDao;
import com.kbao.kbcassist.job.entity.JobLocksMo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.data.mongodb.core.query.Update;
import org.springframework.stereotype.Repository;

import java.time.LocalDateTime;

/**
 * @className: JobLocksMongoDaoImpl
 * @description: 定时任务锁DAO
 * @author: wangzb01
 * @version: V1.0
 * @since: V1.0
 * @className: 2021-01-29 11:05
 */
@Repository
public class JobLocksMongoDaoImpl implements JobLocksMongoDao {

    @Autowired
    private MongoTemplate mongoTemplate;

    @Override
    public void save(JobLocksMo jobLocksMo) {
        mongoTemplate.save(jobLocksMo);
    }

    @Override
    public JobLocksMo findById(String id) {
        return mongoTemplate.findById(id, JobLocksMo.class);
    }

    @Override
    public JobLocksMo lock(String id, Long version) {
        Query query = new Query();
        Criteria criteria = new Criteria();
        criteria.and("id").is(id);
        criteria.and("status").is(0);
        criteria.and("version").is(version);
        query.addCriteria(criteria);
        Update update = new Update();
        update.set("status", 1);
        update.inc("version", 1);
        update.set("updateId", "system_job_lock");
        update.set("updateTime", LocalDateTime.now());
        return mongoTemplate.findAndModify(query, update, JobLocksMo.class);
    }

    @Override
    public JobLocksMo unlock(String id) {
        Query query = new Query();
        Criteria criteria = new Criteria();
        criteria.and("id").is(id);
        criteria.and("status").is(1);
        query.addCriteria(criteria);
        Update update = new Update();
        update.set("status", 0);
        update.set("updateId", "system_job_unlock");
        update.set("updateTime", LocalDateTime.now());
        return mongoTemplate.findAndModify(query, update, JobLocksMo.class);
    }
}

• 多线程定时任务

package com.kbao.kbcassist.task;

import com.kbao.kbcassist.common.dao.JobLocksMongoDao;
import com.kbao.kbcassist.email.service.CaseEmailService;
import com.kbao.kbcassist.job.entity.JobLocksMo;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.Scheduled;

/**
 * @className: ScheduleTask
 * @description: 多线程定时任务
 * @author: wangzb01
 * @version: V1.0
 * @since: V1.0
 * @className: 2020-12-16 11:10
 * @Configuration 主要用于标记配置类，兼备Component的效果。
 * @EnableScheduling 开启定时任务
 * @EnableAsync 开启多线程
 */
@Slf4j
@Configuration
public class ScheduleTask {

    @Autowired
    private CaseEmailService caseEmailService;

    @Autowired
    private JobLocksMongoDao jobLocksMongoDao;

    /**
     * @param
     * @return void
     * @description 每天早上6点开始，每隔一小时定时收件，每三分钟跑一次
     * @author wangzb01
     * @date 2020-12-16 11:47
     */
    @Async("taskExecutor")
    @Scheduled(cron = "0 0/3 6/1 * * ?")
    public void receiveEmailByTask() {
        JobLocksMo jobLocksMo = null;
        try {
            // 查询分布式定时任务数据库乐观锁
            jobLocksMo = jobLocksMongoDao.findById("distributed_job_lock_email");
            if (null != jobLocksMo && jobLocksMo.getStatus() == 0) {
                // 如果当前任务处于空闲状态则给当前任务加锁，核对版本正确才更新
                JobLocksMo lock = jobLocksMongoDao.lock(jobLocksMo.getId(), jobLocksMo.getVersion());
                if (null != lock) {
                    log.debug("定时任务开启。。。");
                    caseEmailService.receiveEmailByTask();
                    log.debug("定时任务结束。。。");

                    // 线程睡眠一分钟，克服节点服务器的时间漂移问题
                    Thread.sleep(60 * 1000);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 只要是给当前任务加上了锁最后必须释放锁
            if (null != jobLocksMo) {
                jobLocksMongoDao.unlock(jobLocksMo.getId());
            }
        }
    }


}