java - Spring Shedlock 时序问题

Question

我们正在使用 Spring Shedlock 库在集群环境中一次运行一个任务实例。但看起来锁定会一直保持到特定时间(由 lockAtMostFor 属性配置，如果我们不配置，它将从 spring 配置中获取默认值)，而不是直到任务完成。

假设我配置了 lockAtMostFor=15 分钟没有并行任务在任何节点上运行 15 分钟，但 15 分钟后，如果任何节点有机会运行(或手动触发)任务，即使前一个任务未完成其处理，它也能够启动它。

1. Shedlock 是基于时间的吗？

2.Documentation( https://github.com/lukas-krecan/ShedLock ) 表示仅在任务完成时才释放锁，并且 lockAtMostFor 属性仅在节点终止事件中使用，但它不起作用这样，即使任务没有完成，其他节点也可以运行任务，只有在时间未到的情况下(lockAtMostFor属性)，其他节点才会被阻止运行任务

Answer 1

您可以在 documentation 中找到Shedlock 表示，为了延长最大锁定时间 lockAtMostUntil，您必须手动创建 SimpleLock 和 extend() 方法。请记住，您还必须手动调用 extend() 方法，或者通过实现 check() 方法来检查进程是否完成并调用 如果需要的话，可以使用extend()方法，否则，当达到lockAtMostUntil时间时，无论您的进程是否仍在运行，锁都会自动解锁。

在这里，我将解释如何从 LockProvider 手动创建 SimpleLock。有关如何设置数据库的问题，我建议您阅读documentation的这一部分谢洛克。

我的应用程序使用了 spring boot，因此您看到的注释来自 spring boot。

依赖关系:

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

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.2.15.RELEASE</version>
</dependency>

LockProvider的配置:

@EnableAsync
@Profile("!unit_test")
@Configuration
public class LockConfiguration {

    @Bean
    public LockProvider lockProvider(DataSource dataSource) {

        return new JdbcTemplateLockProvider(
                JdbcTemplateLockProvider.Configuration.builder()
                        .withTimeZone(TimeZone.getTimeZone("Europe/Rome"))
                        .withJdbcTemplate(new JdbcTemplate(dataSource))
                        .withTableName("shared_lock")
                        .usingDbTime()
                        .build());
    }
}

DistributedLock 这里是我们实现 SimpleLock 和所有需要的相关方法的地方:

@Component
@Slf4j
public class DistributedLockWithExtend {

    @Autowired
    private LockProvider lockProvider;

    private final Map<String, SimpleLock> locks = new HashMap<>();



    public boolean tryLock(String lockname, Duration lockDuration){
        Duration minDuration = Duration.ZERO;
        Instant now = ClockProvider.now();
        LockConfiguration config = new LockConfiguration(now, lockname, lockDuration, minDuration);
        Optional<SimpleLock> lockLocal = lockProvider.lock(config);
        if(lockLocal.isPresent()) {
            locks.put(lockname, lockLocal.get());
            log.debug("lock is created!");
            return true;
        }else {
            log.debug("lock is locked!");
            return false;
        }
    }

    public boolean extendLock(String lockname, Duration duration){
        Duration minDuration = Duration.ZERO;
        SimpleLock lock = locks.get(lockname);
        if(lock != null) {
            Optional<SimpleLock> localLock = lock.extend(duration, duration);
            locks.put(lockname, localLock.get());
            log.debug("Lock is extended");
            return true;
        }else {
            log.debug("There is no lock or the lock is already unlocked! Create a lock with tryLock() if you need!");
            return false;
        }

    }

    public String unLock(String lockname){

        SimpleLock lock = locks.get(lockname);
        if(lock != null) {
            locks.remove(lockname);
            lock.unlock();
            log.debug("Lock is unLocked!");
            return "Lock is unLocked!";
        }else {
            log.debug("There is no lock or the lock is already unlocked! Create a lock if you need!");
            return "There is no lock or the lock is already unlocked! Create a lock if you need!";
        }



    }
}

这是我创建的一个测试 RestController，用于演示 DistributedLockWithExtend 方法的用法:

@Profile("!unit_test")
@RestController
@RequestMapping(TestLockController.PATH)
public class TestLockController {

    public static final  String PATH = BaseController.PATH + "/test-lock";

    @Autowired
    ApplyPolicyScheduler applyPolicySchedular;

    @Autowired
    DistributedLockWithExtend distributedLockWithExtend;

    @GetMapping("/up")
    public String testService(){
        return "Service is up!";
    }

    @GetMapping("/invoke")
    public String invokeTest(){

        return distributedLockWithExtend.tryLock("testLockUtil", Duration.ofMinutes(1)) + "";
    }

    @GetMapping("/extend")
    public String extendTest(){

        return distributedLockWithExtend.extendLock("testLockUtil", Duration.ofMinutes(3)) + "";
    }

    @GetMapping("/unlock")
    public String unlockTest(){

         distributedLockWithExtend.unLock("testLockUtil");
         return "Unlock called!";
    }
}