上一篇 <<
单机环境下的分布式锁类
public class JaryeRedisLock {
private static final int setnxSuccss = 1;
/**
* 获取锁
*
* @param lockKey 定义锁的key
* @param notLockTimeOut 没有获取锁的超时时间
* @param lockTimeOut 使用锁的超时时间
* @return
*/
public String getLock(String lockKey, int notLockTimeOut, int lockTimeOut) {
// 获取Redis连接
Jedis jedis = RedisUtil.getJedis();
// 定义没有获取锁的超时时间
Long endTimeOut = System.currentTimeMillis() + notLockTimeOut;
while (System.currentTimeMillis() < endTimeOut) {
String lockValue = UUID.randomUUID().toString();
// 如果在多线程情况下谁能够setnx 成功返回0 谁就获取到锁
if (jedis.setnx(lockKey, lockValue) == setnxSuccss) {
jedis.expire(lockKey, lockTimeOut / 1000);
return lockValue;
}
// 否则情况下 在超时时间内继续循环
}
try {
if (jedis != null) {
jedis.close();
}
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
/**
* 释放锁 其实就是将该key删除
*
* @return
*/
public Boolean unLock(String lockKey, String lockValue) {
Jedis jedis = RedisUtil.getJedis();
// 确定是对应的锁 ，才删除
if (lockValue.equals(jedis.get(lockKey))) {
return jedis.del(lockKey) > 0 ? true : false;
}
return false;
}
}
public class OrderService {
private JaryeRedisLock jaryeRedisLock = new JaryeRedisLock();
private String lockKey = "jarye_lock";
public void service() {
// 1.获取锁
String lockValue = jaryeRedisLock.getLock(lockKey, 1000, 1000);
if (StringUtils.isEmpty(lockValue)) {
System.out.println(Thread.currentThread().getName() + ",获取锁失败!");
return;
}
// 2.获取锁成功执行业务逻辑
System.out.println(Thread.currentThread().getName() + ",获取成功，lockValue：" + lockValue);
// // 3.释放lock锁
jaryeRedisLock.unLock(lockKey, lockValue);
}
public static void main(String[] args) {
OrderService service = new OrderService();
service.service();
System.out.println("程序已完結");
}
}
集群环境下的分布式锁类
集群环境下的IP和端口可以直接配置一个，JedisCluster实例时会自动寻址找到所有信息
public class DistributedLockUtil
{
private static final String LOCK_SUCCESS = "OK";
private static final String SET_IF_NOT_EXIST = "NX";
private static final String SET_WITH_EXPIRE_TIME = "PX";
private static final Long RELEASE_SUCCESS = 1L;
/**
* 尝试获取分布式锁
* @param jd RedisCluster客户端
* @param lockKey 锁
* @param requestId 请求标识
* @param expireTime 超期时间
* @return 是否获取成功
*/
public static boolean tryGetDistributedLock(JedisCluster jd, String lockKey, String requestId, int expireTime)
{
String result = jd.set(lockKey, requestId, SET_IF_NOT_EXIST, SET_WITH_EXPIRE_TIME, expireTime);
if (LOCK_SUCCESS.equals(result))
{
return true;
}
return false;
}
/**
* 释放分布式锁
* @param jd RedisCluster客户端
* @param lockKey 锁
* @param requestId 请求标识
* @return 是否释放成功
*/
public static boolean releaseDistributedLock(JedisCluster jd, String lockKey, String requestId)
{
String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
Object result = jd.eval(script, Collections.singletonList(lockKey), Collections.singletonList(requestId));
if (RELEASE_SUCCESS.equals(result))
{
return true;
}
return false;
}
}
Springboot下使用分布式锁
//分布式锁使用时一般这么写：
a、获得锁
b、如果未获得锁则友好提示
try{
c、业务逻辑
}finally{
d、释放锁
}
- 影响锁的效率：
1、key是全局唯一的
2、锁的粒度
- 如何提高分布式锁的效率：
1、降低锁的粒度
a、上面b步骤放在try的外面
b、业务逻辑代码尽可能的简单
2、不同的业务使用不同的锁，不要全部用同一把锁
- 集群情况下，使用redisTemplate.opsForCluster()
public class RedisLockUtil {
/**
* 可以使用SpringUtils.getBean(StringRedisTemplate.class);获得bean
*/
private StringRedisTemplate redisTemplate =null;
/**
* 分布式锁名称
*/
private String lockName;
/**
* 超时时间
*/
private int timeOut = 30;
/**
* 看门狗线程，可以给分布式锁续期，用于解决业务还没完成，但分布式锁已到期了【缺点：业务死锁，会导致永远获取不了当前锁】
*/
private Thread threadDog;
/**
* 本地变量，保证获得锁和释放锁是同一个线程
*/
private static ThreadLocal threadLocal = new InheritableThreadLocal();
private RedisLockUtil(String lockName) {
this.lockName = lockName;
}
/**
* 获得实例
*/
public static RedisLockUtil getRedisLock(String lockName) {
return new RedisLockUtil(lockName);
}
/**
* 上锁
* @return
*/
public Boolean lock() {
String value = UUID.randomUUID().toString();
boolean store = redisTemplate.opsForValue().setIfAbsent(lockName,value);
if(store){
//设置过期时间，防止程序死循环导致锁无法释放
redisTemplate.expire(lockName,timeOut,TimeUnit.SECONDS);
threadLocal.set(value);
dogMonitorStart();
}
return store;
}
private void dogMonitorStart() {
threadDog = new Thread(()->{
while (true) {
String uuid = (String)threadLocal.get();
if(StringUtils.isBlank(uuid)){
return;
}
boolean flg = redisTemplate.expire(lockName, timeOut, TimeUnit.SECONDS);
if(!flg){
break;
}
try {
TimeUnit.SECONDS.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
threadDog.start();
}
/**
* 释放锁
*/
public void unlock() {
String s = redisTemplate.opsForValue().get(lockName);
if(((String)threadLocal.get()).equals(s)) {
redisTemplate.delete(lockName);
threadDog.stop();
threadLocal.remove();
}
}
}
推荐阅读：
<<<分布式缓存与本地缓存的区别
<<
<<
<<<阿里云的Canal框架配置
<<