用shedlock实现分布式定时任务锁

添加包
<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-jdbc-template</artifactId> 
 
 
       
  <version> 
  2.2 
  . 
  0 
  </version> 
 
 
  </dependency> 
 

   添加表 
 
CREATE TABLE `shedlock` (
 `name` varchar(64) COLLATE utf8mb4_unicode_ci NOT NULL,
 `lock_until` timestamp(3) NULL DEFAULT NULL,
 `locked_at` timestamp(3) NULL DEFAULT NULL,
 `locked_by` varchar(255) COLLATE utf8mb4_unicode_ci DEFAULT NULL,
 PRIMARY KEY (`name`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
添加config
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 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();
    }
}
具体的定时任务import net.javacrumbs.shedlock.core.SchedulerLock;
import net.javacrumbs.shedlock.spring.annotation.EnableSchedulerLock;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

@Component
@Configuration
@EnableScheduling
@EnableSchedulerLock(defaultLockAtMostFor = "PT30S") //重点地方
public class MarkRefreshScheduler {

    private final static Logger logger = LoggerFactory.getLogger(MarkRefreshScheduler.class);


    //每周一早上5点执行一次，用户的热度值和hot标识归零
    @Scheduled(cron = "0 0/2 * * * ? ")
    @SchedulerLock(name = "headNumCronName", lockAtMostFor = 5 * 1000, lockAtLeastFor = 5 * 1000)//重点地方
    public void refreshHotSumAndIsOnTop() {
        logger.info("begin refreshHotSumAndIsOnTop...");
        //do something
        logger.info("begin refreshHotSumAndIsOnTop...");

    }
}
结果通过修改数据库表中的数据实现锁
里面有四个字段
主键name：每个定时任务的一个名字
locked_at：锁的开始时间
lock_until：锁的结束时间
再定时开始时，会更新这两个时间，在时间之内的定时是不会被执行的
用shedlock实现分布式定时任务锁

猜你喜欢
