Shedlock与多节点定时任务锁

ShedLock只做一件事。它确保您的计划任务最多同时执行一次。如果正在一个节点上执行任务，它将获取一个锁，以防止从另一个节点（或线程）执行相同的任务。

如果一个任务已在一个节点上执行，则其他节点上的执行不会等待，只会跳过它。

属性

@SchedulerLock注解有name ,lockAtMostFor ,lockAtLeastFor 三个属性

name ：锁名，名称相同的定时器，每次只会执行一个，name类似分组

lockAtMostFor：该属性指定在执行节点死亡时应保留锁的时间。这只是一个后备，在正常情况下，锁定会在任务完成后立即释放，

lockAtLeastFor属性，指定保留锁的最短时间。主要目的是在任务非常短的且节点之间存在时钟差异的情况下防止多个节点执行。这个属性是锁的持有时间。设置了多少就一定会持有多长时间，再次期间，下一次任务执行时，其他节点包括它本身是不会执行任务的。

在springboot中配置

需要在你的项目中引入两个包

        <dependency>
            <groupId>net.javacrumbs.shedlock</groupId>
            <artifactId>shedlock-spring</artifactId>
            <version>2.1.0</version>
        </dependency>
        <dependency>
            <groupId>net.javacrumbs.shedlock</groupId>
            <artifactId>shedlock-provider-jdbc-template</artifactId>
            <version>2.2.0</version>
        </dependency>

在你的启动类中增加注解支持

@EnableScheduling
@EnableSchedulerLock(defaultLockAtMostFor = "PT30S")

需要初始化Provider支持。操作数据库。

@Configuration
public class LockProviderConfig {

    @Autowired DataSource dataSource;
    
    @Bean
    public LockProvider lockProvider () {
        return new JdbcTemplateLockProvider(dataSource);
    }
}

这里全局datasource需要事先创建好。在这里可以直接注入使用。然后实例化jdbcTemplateLockProvider。

• 建表

CREATE TABLE shedlock(
    name VARCHAR(64), 
    lock_until TIMESTAMP(3) NULL, 
    locked_at TIMESTAMP(3) NULL, 
    locked_by  VARCHAR(255), 
    PRIMARY KEY (name)
)

写一个测试类

@Component
public class RiskAdminScheduler {

    private static final String SIXTY_MIN = "PT60M";
    private static final String THREE_MIN = "PT3M";

    @Scheduled(cron = "0 */1 * * * ? ")
    @SchedulerLock(name = "test",lockAtLeastForString = THREE_MIN,lockAtMostForString = SIXTY_MIN)
    public void test() {
          log.info("LocalDateTime: {}", LocalDateTime.now());
        log.info("Thread --executed...... : {}", Thread.currentThread().getName());
    }
}

name的含义：定时任务的名称。这个必须全局唯一。这个是定时任务的标识。
lockAtLeastForString & lockAtMostForString我想引用官方的解释更明白一点：By setting lockAtMostFor we make sure that the lock is released even if the node dies and by setting lockAtLeastFor we make sure it's not executed more than once in fifteen minutes.
意思就是，当节点挂掉后，这个锁还是要释放的。最长时间就是most设置的

least时间设置了后，这里是1分钟定时任务执行一次，而least设置是3分钟。那么也就是3分钟是持有锁的最小时间，3分钟后才释放。所以1分钟执行完的定时任务，必须等到3分钟结束，锁释放后，才能再次执行。

看到的日志输入是三分钟一次，在锁的状态没有运行，同样两个节点，只能其中一个节点才能运行。完美解决当前问题

image-20221229172751039.png image-20221229172821281.png image-20221229172835782.png

锁原理

1、获取锁

（1） lockProvider.lock(lockConfig);

StorageBasedLockProvider.java

 public Optional<SimpleLock> lock(@NonNull LockConfiguration lockConfiguration) {
        //获取锁
        boolean lockObtained = doLock(lockConfiguration);
        if (lockObtained) {
            //生成StorageLock
            return Optional.of(new StorageLock(lockConfiguration, storageAccessor));
        } else {
            return Optional.empty();
        }
    }

（2）doLock( )

 protected boolean doLock(LockConfiguration lockConfiguration) {
        String name = lockConfiguration.getName();
        
        //检查缓存lockRecordRegistry中有没有该锁的记录
        if (!lockRecordRegistry.lockRecordRecentlyCreated(name)) {
            // create record in case it does not exist yet
            //没有记录该锁，尝试insert一条记录到数据库
            if (storageAccessor.insertRecord(lockConfiguration)) {
                //加入缓存
                lockRecordRegistry.addLockRecord(name);
                // we were able to create the record, we have the lock
                return true;
            }
            // we were not able to create the record, it already exists, let's put it to the cache so we do not try again
            //加入缓存
            lockRecordRegistry.addLockRecord(name);
        }

        // let's try to update the record, if successful, we have the lock
        //
        return storageAccessor.updateRecord(lockConfiguration);
    }

insertRecord( )

往数据库插入一条记录，生成锁，执行的sql为

INSERT INTO shedlock(name, lock_until, locked_at, locked_by) VALUES(:name, :lockUntil, :now, :lockedBy)

2、更新锁 updateRecord( )

UPDATE shedlock SET lock_until = :lockUntil, locked_at = :now, locked_by = :lockedBy WHERE name = :name AND lock_until <= :now

更新的条件是根据锁的名称和 lock_until 的时间比当前时间要小，也就是上一个获取锁的任务截止时间已经到了

@Override
    public boolean updateRecord(@NonNull LockConfiguration lockConfiguration) {
        String sql = sqlStatementsSource().getUpdateStatement();
        try {
            return execute(sql, lockConfiguration);
        } catch (CannotSerializeTransactionException e) {
            return false;
        } catch (DataIntegrityViolationException | TransactionSystemException e) {
            logger.error("Unexpected exception", e);
            return false;
        }
    }

3、释放锁lock.get().unlock()

UPDATE shedlock SET lock_until = :unlockTime WHERE name = :name

其中unlockTime 为lockAtLeastFor和当前时间中的最大值，也就是为当前任务持有锁的时间截止时间

public final void unlock() {
        checkValidity();
        doUnlock();
        valid = false;
    }

  public void doUnlock() {
            storageAccessor.unlock(lockConfiguration);
        }

JdbcTemplateStorageAccessor.java

 public void unlock(@NonNull LockConfiguration lockConfiguration) {
        try {
            doUnlock(lockConfiguration);
        } catch (TransactionSystemException e) {
            logger.info("Unlock failed due to TransactionSystemException - retrying");
            doUnlock(lockConfiguration);
        }
    }

 private void doUnlock(LockConfiguration lockConfiguration) {
        String sql = sqlStatementsSource().getUnlockStatement();
        execute(sql, lockConfiguration);
    }

    @SuppressWarnings("ConstantConditions")
    private boolean execute(String sql, LockConfiguration lockConfiguration) throws TransactionException {
        return transactionTemplate.execute(status -> jdbcTemplate.update(sql, params(lockConfiguration)) > 0);
    }

只有简单配置，便很好就解决了多节点服务器锁问题。

2022/12 成都