package org.sxkj.common.redis;
|
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
import org.springframework.data.redis.core.RedisCallback;
|
import org.springframework.data.redis.core.RedisTemplate;
|
import org.springframework.data.redis.serializer.RedisSerializer;
|
|
import java.util.Objects;
|
import java.util.concurrent.TimeUnit;
|
import java.util.function.Consumer;
|
import java.util.function.Function;
|
import java.util.function.Supplier;
|
|
|
/**
|
* redis 集群共享锁
|
*
|
* @author raojiangang
|
*/
|
public class RedisLockUtils<P, R> {
|
private static final Logger LOG = LoggerFactory.getLogger(RedisLockUtils.class);
|
|
/**
|
* 加锁超时时间，单位毫秒，
|
* 30秒超时
|
*/
|
private static final long LOCK_TIMEOUT = 30 * 1000;
|
|
private RedisTemplate<String, String> primaryStringRedisTemplate;
|
|
public RedisLockUtils(RedisTemplate redisTemplate) {
|
this.primaryStringRedisTemplate = redisTemplate;
|
}
|
|
|
|
/**
|
* 加锁
|
* 取到锁加锁，取不到锁一直等待知道获得锁
|
*
|
* @param lockKey key
|
* @return 时间毫秒
|
*/
|
private synchronized long lock(String lockKey) {
|
while (true) {
|
//锁时间
|
long lockTimeout = currentTimeForRedis() + LOCK_TIMEOUT + 1;
|
if (serializerRedisKey(lockKey, lockTimeout)) {
|
|
//设置超时时间，释放内存
|
primaryStringRedisTemplate.expire(lockKey, LOCK_TIMEOUT, TimeUnit.MILLISECONDS);
|
return lockTimeout;
|
} else {
|
//获取redis里面的时间
|
Object result = primaryStringRedisTemplate.opsForValue().get(lockKey);
|
|
Long currLockTimeoutStr = result == null ? null : Long.parseLong(result.toString());
|
//锁已经失效
|
if (currLockTimeoutStr != null && currLockTimeoutStr < System.currentTimeMillis()) {
|
Object andSet = primaryStringRedisTemplate.opsForValue().getAndSet(lockKey, Long.toString(lockTimeout));
|
Long oldLockTimeoutStr = Long.valueOf(
|
Objects.requireNonNull(
|
andSet.toString())
|
);
|
if (oldLockTimeoutStr.equals(currLockTimeoutStr)) {
|
primaryStringRedisTemplate.expire(lockKey, LOCK_TIMEOUT, TimeUnit.MILLISECONDS);
|
|
return lockTimeout;
|
}
|
}
|
}
|
try {
|
TimeUnit.MILLISECONDS.sleep(200);
|
} catch (InterruptedException e) {
|
e.printStackTrace();
|
}
|
}
|
}
|
|
private Boolean serializerRedisKey(String lockKey, Long lockTimeout) {
|
return primaryStringRedisTemplate.execute((RedisCallback<Boolean>) redisConnection -> {
|
//定义序列化方式
|
RedisSerializer<String> serializer = primaryStringRedisTemplate.getStringSerializer();
|
byte[] value = serializer.serialize(lockTimeout.toString());
|
return (boolean) redisConnection.setNX(lockKey.getBytes(), value);
|
});
|
}
|
|
/**
|
* 解锁
|
*
|
* @param lockKey key
|
* @param lockValue value
|
*/
|
private synchronized void unlock(String lockKey, long lockValue) {
|
LOG.info("==========执行解锁==========");
|
//获取redis中设置的时间
|
Object result = primaryStringRedisTemplate.opsForValue().get(lockKey);
|
Long currentLockTimeoutStr = result == null ? null : Long.valueOf(result.toString());
|
|
//如果是加锁者，则删除锁， 如果不是，则等待自动过期，重新竞争加锁
|
if (currentLockTimeoutStr != null && currentLockTimeoutStr == lockValue) {
|
primaryStringRedisTemplate.delete(lockKey);
|
LOG.info("==========解锁成功==========");
|
}
|
}
|
|
/**
|
* 获取服务时间
|
*
|
* @return 时间戳
|
*/
|
private long currentTimeForRedis() {
|
return primaryStringRedisTemplate.execute(
|
(RedisCallback<Long>) redisConnection -> redisConnection.time());
|
}
|
|
|
/**
|
* redis 全局锁
|
* 有参有返回值
|
*
|
* @param lockKey key
|
* @param function fun
|
*/
|
public R tryLock(String lockKey, P param, Function<P, R> function) {
|
R result = null;
|
try {
|
long lockTime = lock(lockKey);
|
result = function.apply(param);
|
//释放锁
|
unlock(lockKey, lockTime);
|
} catch (Exception e) {
|
throw e;
|
} finally {
|
deleteKey(lockKey);
|
}
|
return result;
|
}
|
|
/**
|
* redis 全局锁
|
* 有参有返回值
|
*
|
* @param lockKey key
|
* @param function fun
|
*/
|
public R tryLock(String lockKey, Supplier<R> function) {
|
R result = null;
|
try {
|
long lockTime = lock(lockKey);
|
result = function.get();
|
//释放锁
|
unlock(lockKey, lockTime);
|
} catch (Exception e) {
|
throw e;
|
} finally {
|
deleteKey(lockKey);
|
}
|
return result;
|
}
|
|
/**
|
* redis 全局锁
|
* 有参 无返回值
|
*
|
* @param lockKey key
|
* @param consumer fun
|
*/
|
public void tryLock(String lockKey, P param, Consumer<P> consumer) {
|
try {
|
long lockTime = lock(lockKey);
|
//执行
|
consumer.accept(param);
|
//释放锁
|
unlock(lockKey, lockTime);
|
} finally {
|
deleteKey(lockKey);
|
}
|
}
|
|
/**
|
* redis 全局锁
|
* 无参无返回值
|
*
|
* @param lockKey key
|
* @param runnable fun
|
*/
|
public void tryLock(String lockKey, Runnable runnable) {
|
try {
|
long lockTime = lock(lockKey);
|
//执行
|
runnable.run();
|
//释放锁
|
unlock(lockKey, lockTime);
|
|
} finally {
|
deleteKey(lockKey);
|
}
|
}
|
|
private void deleteKey(String lockKey) {
|
primaryStringRedisTemplate.delete(lockKey);
|
}
|
|
}
|
