分布式任务调度-定时任务重复执行解决方案
最近一期需求遇到这么个问题，需要写一个定时任务，项目是集群部署的并且服务器资源有限没有redis、Zookeeper等。
我们都知道，当我们服务端在部署集群模式时，会出现所有的定时任务在各自的节点处都会执行一遍，这显然是不符合要求的，如何解决这个问题？那就是引入分布式锁。
分布式锁三种实现方式：1、基于数据库实现分布式锁；2、基于缓存（Redis等）实现分布式锁；3、基于Zookeeper实现分布式锁
基于Redis实现分布式锁的传送门：redis分布式锁
那要怎么解决呢？没错，就是使用第一种方式：基于数据库实现分布式锁
本文给出一种springboot集成shedlock的解决方案，以及对shedlock的大致实现原理的源码解析
1.引入相关jar包
<dependency>
<groupId>net.javacrumbs.shedlock</groupId>
<artifactId>shedlock-spring</artifactId>
<version>2.2.1</version>
</dependency>
<dependency>
<groupId>net.javacrumbs.shedlock</groupId>
<artifactId>shedlock-provider-jdbc-template</artifactId>
<version>2.2.1</version>
</dependency>
2.数据库新建表
CREATE TABLE `t_scheduled_lock` ( `NAME` varchar(64) COLLATE utf8mb4_unicode_ci NOT NULL COMMENT '任务名称', `lock_until` timestamp(3) NULL DEFAULT NULL COMMENT '到期时间', `locked_at` timestamp(3) NULL DEFAULT NULL COMMENT '开始时间', `locked_by` varchar(255) COLLATE utf8mb4_unicode_ci DEFAULT NULL, PRIMARY KEY (`NAME`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='分布式任务调度锁表';
3.配置类
import net.javacrumbs.shedlock.core.LockProvider; import net.javacrumbs.shedlock.provider.jdbctemplate.JdbcTemplateLockProvider; import net.javacrumbs.shedlock.spring.ScheduledLockConfiguration; import net.javacrumbs.shedlock.spring.ScheduledLockConfigurationBuilder; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.scheduling.annotation.EnableScheduling; import javax.sql.DataSource; import java.time.Duration; @Configuration @EnableScheduling public class ScheduledConfig { @Bean public LockProvider lockProvider(DataSource dataSource) { //指定表名，会自动在数据库中记录任务执行日志 return new JdbcTemplateLockProvider(dataSource,"t_scheduled_lock"); } @Bean public ScheduledLockConfiguration scheduledLockConfiguration(LockProvider lockProvider) { return ScheduledLockConfigurationBuilder .withLockProvider(lockProvider) .withPoolSize(10) .withDefaultLockAtMostFor(Duration.ofMinutes(30)) .build(); } }
4.在启动类添加注解
//默认持有锁时间=30分钟 @EnableSchedulerLock(defaultLockAtMostFor = "PT30M")
5.添加定时任务方法
@RequestMapping(value ="/text", method = {RequestMethod.GET,RequestMethod.POST}) // @Scheduled(cron = "-") //表示不执行 @Scheduled(cron = "0 0 0 * * ?") //表示每天0点执行 @SchedulerLock(name = "test",lockAtLeastForString = "PT30M") public void test() { // do something... }
@SchedulerLock注解有以下几个属性
name：锁名称，锁名称必须是全局唯一的;
lockAtMostFor(单位：毫秒)：设置锁的最大持有时间,为了解决如果持有锁的节点挂了,无法释放锁,其他节点无法进行下一次任务，正常情况下任务执行完就会释放锁；
lockAtMostForString：锁的最大持有时间的字符串表达，例如“PT30M”表示为30分钟；
lockAtLeastFor(单位：毫秒)：保留锁的最短时间。这个属性是锁的持有时间。设置了多少就一定会持有多长时间，再此期间，下一次任务执行时，其他节点包括它本身是不会执行任务的；
lockAtLeastForString：保留锁的最短时间的字符串表达，例如“PT30M”表示为30分钟
拿我上面的代码解释一下：锁test设置了lockAtLeastFor或者lockAtLeastForString属性的值为30分钟，就意味这30分钟内，text()方法不会执行第二遍，30分钟后才会执行下一次的任务调度。
源码解析:
假如这个定时任务开发环境不执行，但是测试环境跟生产环境又执行
可以这么设置@Scheduled(cron = "-")，可以将cron的值写在不同环境的配置文件中
因为在ScheduledAnnotationBeanPostProcessor.java中的processScheduled()方法提到
接下来我们看看@SchedulerLock是如何加锁的
1.在DefaultLockingTaskExecutor.class中executeWithLock方法写到，先执行加锁lock，加锁成功则执行任务，最后unlock释放锁，加锁不成功则提示It's locked
public void executeWithLock(Task task, LockConfiguration lockConfig) throws Throwable { Optional<SimpleLock> lock = this.lockProvider.lock(lockConfig); if (lock.isPresent()) { try { logger.debug("Locked {}.", lockConfig.getName()); task.call(); } finally { ((SimpleLock)lock.get()).unlock(); logger.debug("Unlocked {}.", lockConfig.getName()); } } else { logger.debug("Not executing {}. It's locked.", lockConfig.getName()); } }
2.再看看lock()方法是怎么写的，StorageBasedLockProvider.class中有提到，意思是先去判断当前的任务name是否添加过，如果没有则执行insertRecord做新增操作，新增成功则保存当前任务的名称，若新增失败，则执行updateRecord更新操作，最终返回新增或更新的结果。注意：这里有可能新增或更新失败，为什么？因为我们是集群部署的，定时任务同一时刻同时执行时，两个不同的线程会同时去执行新增或更新，那么问题来了，为什么最终会只有一个线程成功呢？继续看看insertRecord方法或者updateRecord方法内部怎么写的了
public Optional<SimpleLock> lock(LockConfiguration lockConfiguration) { boolean lockObtained = this.doLock(lockConfiguration); return lockObtained ? Optional.of(new StorageBasedLockProvider.StorageLock(lockConfiguration, this.storageAccessor)) : Optional.empty(); } protected boolean doLock(LockConfiguration lockConfiguration) { String name = lockConfiguration.getName(); if (!this.lockRecordRegistry.lockRecordRecentlyCreated(name)) { if (this.storageAccessor.insertRecord(lockConfiguration)) { this.lockRecordRegistry.addLockRecord(name); return true; } this.lockRecordRegistry.addLockRecord(name); } return this.storageAccessor.updateRecord(lockConfiguration); }
3.JdbcTemplateStorageAccessor.class
//insertRecord方法其实就是对数据库插入一条锁的记录，包括锁名称，锁到期时间，锁开始时间以及加锁的来源，然后将插入的结果返回
public boolean insertRecord(LockConfiguration lockConfiguration) { String sql = "INSERT INTO " + this.tableName + "(name, lock_until, locked_at, locked_by) VALUES(?, ?, ?, ?)"; return (Boolean)this.transactionTemplate.execute((status) -> { try { int insertedRows = this.jdbcTemplate.update(sql, (preparedStatement) -> { preparedStatement.setString(1, lockConfiguration.getName()); this.setTimestamp(preparedStatement, 2, lockConfiguration.getLockAtMostUntil()); this.setTimestamp(preparedStatement, 3, Instant.now()); preparedStatement.setString(4, this.getHostname()); }); return insertedRows > 0; } catch (DataIntegrityViolationException var5) { return false; } }); }
//updateRecord方法就是更新数据库的记录，注意where条件，它会更新（当前锁名称+锁的到期时间<=当前时间）的记录，并且返回更新结果
//举个例子：有一条name=test的锁记录，lock_until锁到期时间是中午12点半，当中午12点时定时任务test执行，执行update更新语句事数据库会返回影响条数0条
//因为test这个锁还没到释放的时间，所以updateRecord方法返回值是true public boolean updateRecord(LockConfiguration lockConfiguration) { String sql = "UPDATE " + this.tableName + " SET lock_until = ?, locked_at = ?, locked_by = ? WHERE name = ? AND lock_until <= ?"; return (Boolean)this.transactionTemplate.execute((status) -> { int updatedRows = this.jdbcTemplate.update(sql, (statement) -> { Instant now = Instant.now(); this.setTimestamp(statement, 1, lockConfiguration.getLockAtMostUntil());//锁的到期时间 this.setTimestamp(statement, 2, now); statement.setString(3, this.getHostname()); statement.setString(4, lockConfiguration.getName()); this.setTimestamp(statement, 5, now); }); return updatedRows > 0; }); }
其实说到这里，还是没能解答我们上面提到的问题：为什么最终会只有一个线程成功呢？看一下transactionTemplate.execute的源码你就懂了
@Override @Nullable public <T> T execute(TransactionCallback<T> action) throws TransactionException { Assert.state(this.transactionManager != null, "No PlatformTransactionManager set"); if (this.transactionManager instanceof CallbackPreferringPlatformTransactionManager) { return ((CallbackPreferringPlatformTransactionManager) this.transactionManager).execute(this, action); } else { TransactionStatus status = this.transactionManager.getTransaction(this); T result; try { result = action.doInTransaction(status); } catch (RuntimeException | Error ex) { // Transactional code threw application exception -> rollback rollbackOnException(status, ex); throw ex; } catch (Throwable ex) { // Transactional code threw unexpected exception -> rollback rollbackOnException(status, ex); throw new UndeclaredThrowableException(ex, "TransactionCallback threw undeclared checked exception"); } this.transactionManager.commit(status); return result; } }
可以看出，当A线程先执行新增或者更新数据时，会为这条数据添加事务并且为数据添加排他锁，其他B、C、D等线程会一直等待A线程的事务处理完。当A处理完时，其他线程才能继续对这条数据进行加锁处理，发现加锁不成功（因为已经有其他线程比它先行一步处理了），所以就会提示It's locked（上文有提到）
排他锁的定义：若事务T对数据对象A加上X锁，则只允许T读取和修改A，其他任何事务都不能再对A加任何类型的锁，直到T释放A上的锁。这就保证了其他事务在T释放A上的锁之前不能再读取和修改A
线程加锁完成、任务执行完成之后，下一步就是释放锁，看看它是怎么释放锁的
public void unlock(final LockConfiguration lockConfiguration) {
//更新这条数据锁的到期时间 final String sql = "UPDATE " + this.tableName + " SET lock_until = ? WHERE name = ?"; this.transactionTemplate.execute(new TransactionCallbackWithoutResult() { protected void doInTransactionWithoutResult(TransactionStatus status) { JdbcTemplateStorageAccessor.this.jdbcTemplate.update(sql, (statement) -> { JdbcTemplateStorageAccessor.this.setTimestamp(statement, 1, lockConfiguration.getUnlockTime());//获取解锁时间 statement.setString(2, lockConfiguration.getName()); }); } }); }
//获取解锁时间
public Instant getUnlockTime() {
Instant now = Instant.now();//获取当前时间
return this.lockAtLeastUntil.isAfter(now) ? this.lockAtLeastUntil : now;
}
lockAtLeastUntil的值就是上面提到的lockAtLeastFor或者lockAtLeastForString属性经过换算后得到的时间
释放锁的逻辑就是：会用当前时间跟保留锁的最短时间进行比较，如果当前时间小于lockAtLeastUntil，则继续用lockAtLeastUntil更新数据（相当于没更新），如果当前时间大于lockAtLeastUntil，则更新为当前时间（也就是从现在开始，这条数据的锁已经到期了）。
举个例子：数据库有一条中午12点加锁的记录A，并且lockAtLeastFor或者lockAtLeastForString设置了30分钟，就意味着A的释放锁时间=12点30分，也就是lockAtLeastUntil=12点30分 ，在当前时间12点20分线程执行到这里想要释放锁，就会用12点20分跟12点30分进行比较发现结果是小于，则继续用lockAtLeastUntil更新数据（相当于没更新）
以上就是本人对shedlock实现分布式锁理解的整个过程，若有理解不对还望指出，我们共同学习！
