springboot基础(82):分布式定时任务解决方案shedlock

前言

多节点或者多服务器拥有相同的定时任务，这种情况下，不同节点的相同定时任务会被重复执行。如何解决分布式定时任务重复执行问题？此刻我们可以引入分布式定时任务解决shedlock来解决这种定时任务重复执行的问题。

代码已分享至Gitee: https://gitee.com/lengcz/shedlock01

简介

Shedlock是一个基于Java的分布式锁库，用于解决分布式环境下的并发问题。它可以确保同一时间只有一个线程能够获取到锁，从而避免了多线程竞争导致的数据不一致或错误的问题。

Shedlock的原理是在数据库中创建一个特殊的表，用于记录锁的状态和持有者信息。当一个线程想要获取锁时，它会在表中插入一条记录，如果插入成功，则表示该线程成功获取到了锁；否则，表示有其他线程已经获取到了锁，当前线程需要等待。

Shedlock提供了简单易用的API，可以方便地在代码中使用锁。它支持不同的锁提供者，包括数据库（如MySQL、PostgreSQL）、ZooKeeper等。此外，Shedlock还提供了一些高级特性，如自动解锁、锁超时、定时任务等，以满足不同的场景需求。

总的来说，Shedlock是一个可靠、高效的分布式锁库，可以帮助开发者在分布式环境中处理并发问题，保证数据的一致性和正确性。它的设计简单，易于集成和使用，是Java开发者的理想选择之一。

shedlock + db

1. 创建表

CREATE TABLE `shedlock` (
  `name` varchar(64) COLLATE utf8mb4_bin NOT NULL,
  `lock_until` timestamp(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3) ON UPDATE CURRENT_TIMESTAMP(3),
  `locked_at` timestamp(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3),
  `locked_by` varchar(255) COLLATE utf8mb4_bin NOT NULL,
  PRIMARY KEY (`name`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin;

2. 引入依赖

<!--此依赖是shedlock核心依赖包，编译时依赖spring,大版本需要一致-->
        <dependency>
            <groupId>net.javacrumbs.shedlock</groupId>
            <artifactId>shedlock-spring</artifactId>
            <version>2.2.0</version>
        </dependency>
        <!--shedlock+jdbc 方案需要引入此依赖-->
        <dependency>
            <groupId>net.javacrumbs.shedlock</groupId>
            <artifactId>shedlock-provider-jdbc-template</artifactId>
            <version>2.2.0</version>
        </dependency>
        <!--quartz定时任务-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-quartz</artifactId>
        </dependency>
        <!--mysql连接驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <!--lombok-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <!--jdbcTemplate需要的依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>

3. 配置数据源(如果没有配置的话)

spring:
  datasource:
    url: jdbc:mysql://xxx.xxx.xxx.xxx:3306/db1?characterEncoding=UTF-8&useSSL=false   #//
    username: root    #//
    password: 123456   #//
    driver-class-name: com.mysql.cj.jdbc.Driver

4. 配置LockProvider

import net.javacrumbs.shedlock.core.LockProvider;
import net.javacrumbs.shedlock.provider.jdbctemplate.JdbcTemplateLockProvider;
import net.javacrumbs.shedlock.spring.annotation.EnableSchedulerLock;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.scheduling.annotation.EnableScheduling;

import javax.sql.DataSource;

import static net.javacrumbs.shedlock.provider.jdbctemplate.JdbcTemplateLockProvider.Configuration.builder;

@Configuration
@EnableScheduling  //开启定时任务
@EnableSchedulerLock(defaultLockAtMostFor = "PT30S") //默认锁的最大占有30秒，建议在启动类上添加，这里是为了方便
public class SchedulerConfiguration {

    @Autowired
    DataSource dataSource;

    @Bean
    public LockProvider lockProvider() {

//        //可以自定义数据源，可以作为一种考虑，一般不使用这个
//        org.apache.tomcat.jdbc.pool.DataSource dataSource1 = new org.apache.tomcat.jdbc.pool.DataSource();
//        dataSource1.setUrl("jdbc:mysql://127.0.0.1:3306/db1?useUnicode=true&characterEncoding=utf8&useSSL=false");
//        dataSource1.setUsername("root");
//        dataSource1.setPassword("123456");

        LockProvider lockProvider = new JdbcTemplateLockProvider(builder()
                //指定表名
                .withTableName("shedlock")
                //指定数据源，一般使用dataSource而非手动定义的数据源
                .withJdbcTemplate(new JdbcTemplate(dataSource))
                //指定表字段名称，字段数量固定，只能改名称，且只有较高版本的shedlock-provider-jdbc-template依赖才提供该配置项
//                .withColumnNames(new JdbcTemplateLockProvider.ColumnNames("name","lock_until","locked_at","locked_by"))
                //使用数据库时间，只有较高版本的shedlock-provider-jdbc-template依赖才提供该配置项
//                .usingDbTime()
                //作用未知，只有较高版本的shedlock-provider-jdbc-template依赖才提供该配置项
//                .withLockedByValue("myvalue")
                //作用未知，只有较高版本的shedlock-provider-jdbc-template依赖才提供该配置项
//                .withIsolationLevel(1)
                .build());
        return lockProvider;
    }
}

5. 使用

import lombok.extern.slf4j.Slf4j;
import net.javacrumbs.shedlock.core.SchedulerLock;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

@Slf4j
@Component
@EnableScheduling //开启定时任务
public class MyJob {

    @Scheduled(cron = "0,15,30,45 * * * * ?")
    @SchedulerLock(name = "task1", lockAtLeastForString = "PT5S", lockAtMostForString = "PT10S")
    public void task1() {
        log.info("-----task1-------");
    }
}    

定时任务执行后，查看数据库

• name : 定时任务名称，多节点执行定时任务，谁获得锁资源谁执行
• locked_at: 上锁开始时间，就是任务的执行开始时间
• lock_until: 释放锁的时间
• locked_by: 谁操作的，通常会计算机名称

SchedulerLock注解说明

@Target({ElementType.METHOD, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface SchedulerLock {
    /**
    * 任务的名称，同名任务互斥，只会执行一个
    */
    String name() default "";

    /**
    *  锁的最多占用多久,单位毫秒
    */
    long lockAtMostFor() default -1L;

    /**
    * 锁的最多占用多久,字符格式,PT2S 表示2秒，PT2M表示2分钟
    */
    String lockAtMostForString() default "";

    /**
    * 锁的最少占用时间，单位毫秒
    */
    long lockAtLeastFor() default -1L;

    /**
    * 锁的最少占用时间,字符格式,PT2S 表示2秒，PT2M表示2分钟
    */
    String lockAtLeastForString() default "";
}

shedlock + redis

引入依赖，注意建议版本相同，避免可能带来的版本兼容问题。

1. 引入依赖

 <dependency>
            <groupId>net.javacrumbs.shedlock</groupId>
            <artifactId>shedlock-spring</artifactId>
            <version>2.2.0</version>
        </dependency>
 <dependency>
            <groupId>net.javacrumbs.shedlock</groupId>
            <artifactId>shedlock-provider-redis-spring</artifactId>
            <version>2.2.0</version>
        </dependency>

2. 配置LockProvider

    @Bean
    public LockProvider lockProvider(RedisTemplate redisTemplate) {
        return new RedisLockProvider(redisTemplate.getConnectionFactory());
    }

遇到的问题

1.配置shedlock不生效

• 在非springboot中，请确保配置的bean是否被扫描到，确保LockProvider是否被加载到容器中。
• 是否定时任务开启了线程池等

2.报错net/javacrumbs/shedlock/core/LockProvider

请检查shedlock-spring 依赖的spring版本与项目的spring版本是否一致(大版本号是否一致)。

报错net/javacrumbs/shedlock/core/LockProvider

注意 shedlock改版本后，注意检查代码，会存在轻微不同。

shedlock升级高版本

升级到4.46.0后，SchedulerLock会提示废弃

此时需要更换导入新的SchedulerLock注解

import net.javacrumbs.shedlock.spring.annotation.SchedulerLock;

该注解的内容，只有3个参数，lockAtMostFor 锁的最长占有时间，lockAtLeastFor 锁的最小占有时间，单位毫秒

代码

    @Scheduled(cron = "0,15,30,45 * * * * ?")
    @SchedulerLock(name = "task1", lockAtLeastFor = "PT5S", lockAtMostFor = "PT10S")
    public void task1() {
        log.info("-----task1-------");
    }

同名定时任务

同名定时任务只会执行一个，多个节点(节点这里指的是服务，一个服务视为一个节点)相同名称的任务只会有一个获取到锁资源并执行，而同一个节点的同名任务只会有一个被执行，且任务的执行是随机的，没有规律，不能预测下一次谁有执行资格，对于多节点而言，也同样遵循此规则。