shedlock mysql_Shedlock初体验

一、概述

看名字就知道是一个锁，哈哈，这是废话了。

正题：单体应用直接用java的lock就可以了，但是分布式锁，一般要么自己实现，要么使用第三方工具。以下简单说下原理：

锁的目的是强制并行变串行，一般主要采用判断某个标志，谁先改变状态谁拿到锁的方式。标志的载体可以有很多种，总结来说只要是独立的能够存储的就可以，比如数据库，常用的是Redis，性能最好的是Zookeper(想想为啥？)。

然后说下锁的应用，最多的应该就是并行变串行，但还有一种就是谁先抢到谁执行，其它放弃执行。前者，最佳的工具是Redisson，但Redisson提供的可不止锁这一个功能，他把redis的所有功能都做了易用性封装，目的是解耦redis的细节和业务，让开发者能够更集中在业务上而不是redis的细节上。后者，最佳工具是Shedlock，Shedlock支持多种标志载体，如数据库、redis、mongo、memcache等等，并且无缝集成spring、springboot，配置简单，使用简单，官方github地址：https://github.com/lukas-krecan/ShedLock

二、demo

以下以一个简单的示例，来说明下ShedLock的使用(java+redis)。

首先是maven依赖

net.javacrumbs.shedlock

shedlock-spring

2.2.0

net.javacrumbs.shedlock

shedlock-provider-redis-jedis

2.2.0

然后是配置类

RedisConfig.java

import java.lang.reflect.Method;

import org.springframework.beans.factory.annotation.Value;

import org.springframework.cache.CacheManager;

import org.springframework.cache.annotation.CachingConfigurerSupport;

import org.springframework.cache.annotation.EnableCaching;

import org.springframework.cache.interceptor.KeyGenerator;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

import org.springframework.data.redis.cache.RedisCacheManager;

import org.springframework.data.redis.connection.RedisConnectionFactory;

import org.springframework.data.redis.core.RedisTemplate;

import org.springframework.data.redis.core.StringRedisTemplate;

import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;

import com.fasterxml.jackson.annotation.JsonAutoDetect;

import com.fasterxml.jackson.annotation.PropertyAccessor;

import com.fasterxml.jackson.databind.ObjectMapper;

import redis.clients.jedis.JedisPool;

@Configuration

@EnableCaching

public class RedisConfig extends CachingConfigurerSupport {

@Value("${spring.redis.host}")

private String host;

@Value("${spring.redis.port}")

private Integer port;

@Bean

@SuppressWarnings("rawtypes")

public CacheManager cacheManager(RedisTemplate, ?> redisTemplate) {

RedisCacheManager rcm = new RedisCacheManager(redisTemplate);

return rcm;

}

@Bean

@Override

public KeyGenerator keyGenerator() {

return new KeyGenerator() {

@Override

public Object generate(Object target, Method method, Object... params) {

StringBuilder sb = new StringBuilder();

sb.append(target.getClass().getName());

sb.append(method.getName());

for (Object o : params) {

if (o != null) {

sb.append(o.toString());

}

}

return sb.toString();

}

};

}

@Bean

public RedisTemplate myRedisTemplate(RedisConnectionFactory factory) {

StringRedisTemplate srt = new StringRedisTemplate(factory);

Jackson2JsonRedisSerializer j2j = new Jackson2JsonRedisSerializer(Object.class);

ObjectMapper om = new ObjectMapper();

om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);

j2j.setObjectMapper(om);

srt.setValueSerializer(j2j);

srt.afterPropertiesSet();

return srt;

}

@Bean

public JedisPool jedisPool() {

return new JedisPool(this.host, this.port);

}

}

Shedlock.java

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

import net.javacrumbs.shedlock.core.LockProvider;

import net.javacrumbs.shedlock.provider.redis.jedis.JedisLockProvider;

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

import redis.clients.jedis.JedisPool;

@Configuration

@EnableSchedulerLock(defaultLockAtMostFor = "PT60M")

public class ShedLockConfig {

@Bean

public LockProvider lockProvider(JedisPool jedisPool) {

return new JedisLockProvider(jedisPool);

}

}

测试代码

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.scheduling.annotation.EnableScheduling;

import org.springframework.scheduling.annotation.Scheduled;

import org.springframework.stereotype.Service;

import net.javacrumbs.shedlock.core.SchedulerLock;

@Service

@EnableScheduling

public class TestScheduler {

private static final Logger LOGGER = LoggerFactory.getLogger(TestScheduler.class);

private static final String FOUR_SEC = "PT4S";

@Scheduled(cron = "0/5 * * * * ?")

@SchedulerLock(name = "test", lockAtMostForString = FOUR_SEC, lockAtLeastForString = FOUR_SEC)

public void test1() {

LOGGER.info("test1");

}

@Scheduled(cron = "0/5 * * * * ?")

@SchedulerLock(name = "test", lockAtMostForString = FOUR_SEC, lockAtLeastForString = FOUR_SEC)

public void test2() {

LOGGER.info("test2");

}

}

这里面有几个参数，以下是说明：

1、SchedulerLock：核心注解

2、lockAtMostForString：最大锁定时间，这个主要是为了防止实例宕调导致不释放锁而引起的其它存活实例无法执行的问题，此设置必须大于任务执行时间，一般尽可能设置大点

3、lockAtLeastForString：最小锁定时间，这个很重要，如果很低，就可能导致不起作用，一般设置成定时任务小一点，比如定时5秒执行一次，那就设置4秒，定时1个小时，那就设置59分钟(其实这个时间指的是redis的key过期时间)

最后说下那个表达式，前缀PT是固定的，最后的S代表秒，对应的还有M，分钟；H，小时；中间的数据就是具体的时间了，比如PT4S，就是4秒，PT4M就是4分钟。