spring quartz 每天执行一次 spring定时任务重复执行

服务A 不同端口同时跑，定时任务就会重复执行了，

解决方案：

1、数据库实现分布式锁 shedlock；

2、基于缓存（Redis等）实现分布式锁；

3、基于Zookeeper实现分布式锁

介绍第一种方案 + 第3种方案

第一种

pom
		<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>

数据库脚本

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

config配置文件

@Component
public class ShedLockConfig {
    @Bean
    public LockProvider lockProvider(DataSource dataSource) {
        return new JdbcTemplateLockProvider(dataSource);
    }

    @Bean
    public ScheduledLockConfiguration scheduledLockConfiguration(LockProvider lockProvider) {
        return ScheduledLockConfigurationBuilder.withLockProvider(lockProvider)
                .withPoolSize(10)
                .withDefaultLockAtMostFor(Duration.ofMinutes(10))
                .build();
    }
}

启动类加上：

@EnableScheduling
@EnableSchedulerLock(defaultLockAtMostFor = "PT50S")

测试，同时跑两个服务 8080  和 8081


8080：
@Component
public class TestSchedule {
	//定时3s执行一次
    @Scheduled(cron="0/3 * * * * ?")
    //2s释放锁，也就是2s内此任务不能重复执行
    @SchedulerLock(name = "testTask", lockAtMostFor = 2 * 1000, lockAtLeastFor = 2 * 1000)
    /**
     * name：锁名称，锁名称必须是全局唯一的;
     * lockAtMostFor(单位：毫秒)：设置锁的最大持有时间,为了解决如果持有锁的节点挂了,无法释放锁,其他节点无法进行下一次任务，正常情况下任务执行完就会释放锁；
     * lockAtMostForString：锁的最大持有时间的字符串表达，例如“PT30M”表示为30分钟；PT10S 表示为10秒
     * lockAtLeastFor(单位：毫秒)：保留锁的最短时间。这个属性是锁的持有时间。设置了多少就一定会持有多长时间，再此期间，下一次任务执行时，其他节点包括它本身是不会执行任务的；
     * lockAtLeastForString：保留锁的最短时间的字符串表达，例如“PT30M”表示为30分钟
     */
    public void test() {
        System.err.println("localhost:8080 2s 执行一次"+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
    }
}

-------------

8081：
@Component
public class TestSchedule {
	//定时3s执行一次
    @Scheduled(cron="0/3 * * * * ?")
    //2s释放锁，也就是2s内此任务不能重复执行
    @SchedulerLock(name = "testTask", lockAtMostFor = 2 * 1000, lockAtLeastFor = 2 * 1000)
    /**
     * name：锁名称，锁名称必须是全局唯一的;
     * lockAtMostFor(单位：毫秒)：设置锁的最大持有时间,为了解决如果持有锁的节点挂了,无法释放锁,其他节点无法进行下一次任务，正常情况下任务执行完就会释放锁；
     * lockAtMostForString：锁的最大持有时间的字符串表达，例如“PT30M”表示为30分钟；PT10S 表示为10秒
     * lockAtLeastFor(单位：毫秒)：保留锁的最短时间。这个属性是锁的持有时间。设置了多少就一定会持有多长时间，再此期间，下一次任务执行时，其他节点包括它本身是不会执行任务的；
     * lockAtLeastForString：保留锁的最短时间的字符串表达，例如“PT30M”表示为30分钟
     */
    public void test() {
        System.err.println("localhost:8081 2s 执行一次"+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
    }
}

---

第三种

<!-- 分布式定时任务锁 -->
        <!-- https://mvnrepository.com/artifact/net.javacrumbs.shedlock/shedlock-spring -->
        <dependency>
            <groupId>net.javacrumbs.shedlock</groupId>
            <artifactId>shedlock-spring</artifactId>
            <version>4.0.4</version>
        </dependency>
        <!-- 使用redis做分布式任务 -->
        <dependency>
            <groupId>net.javacrumbs.shedlock</groupId>
            <artifactId>shedlock-provider-redis-spring</artifactId>
            <version>2.5.0</version>
        </dependency>


import net.javacrumbs.shedlock.core.LockProvider;
import net.javacrumbs.shedlock.provider.redis.spring.RedisLockProvider;
import net.javacrumbs.shedlock.spring.annotation.EnableSchedulerLock;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.core.RedisTemplate;

/**
 * 分布式定时调度配置
 * <p>
 * SchedulerLock 注解一共支持五个参数，分别是
 * name 用来标注一个定时服务的名字，被用于写入数据库作为区分不同服务的标识，如果有多个同名定时任务则同一时间点只有一个执行成功
 * lockAtMostFor 成功执行任务的节点所能拥有独占锁的最长时间，单位是毫秒ms
 * lockAtMostForString 成功执行任务的节点所能拥有的独占锁的最长时间的字符串表达，例如“PT14M”表示为14分钟
 * lockAtLeastFor 成功执行任务的节点所能拥有独占所的最短时间，单位是毫秒ms
 * lockAtLeastForString 成功执行任务的节点所能拥有的独占锁的最短时间的字符串表达，例如“PT14M”表示为14分钟
 */
@Configuration
@EnableSchedulerLock(defaultLockAtMostFor = "PT30S")
public class ShedLockConfig {
    
    @Bean
    public LockProvider lockProvider(RedisTemplate redisTemplate) {
        return new RedisLockProvider(redisTemplate.getConnectionFactory());
    }

}

@Slf4j
@Component
public class PoducerSched {
    
    @Scheduled(cron = "0/3 * * * * ?")
    @SchedulerLock(name = "test", lockAtMostFor = 2 * 1000)
    public void test() {
        System.err.println("localhost:8081 3s 执行一次"+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
    }

}