package com.mall.common;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import redis.clients.jedis.ShardedJedis;
import redis.clients.jedis.ShardedJedisPool;
@Slf4j
public class DisLock {
@Autowired
private RedisTemplate<String, Object> redisTemplate;
// RedisTemplate
public void oneLock(){
String key = "key-001";
Long currentTime = System.currentTimeMillis();
boolean lock = redisTemplate.opsForValue().setIfAbsent(key, currentTime);
try {
if (lock) {
log.info("获取锁成功,开始逻辑处理");
}else{
log.info("获取锁失败,业务正在处理中,请稍后");
}
}catch (Exception e){
log.error("系统异常",e);
}finally {
if (lock) {
redisTemplate.delete(key);
log.info("处理结束,释放锁!");
} else {
log.info("没有获取到锁,无需释放锁!");
Long createTime = (Long) redisTemplate.opsForValue().get(key);
Long nowTime = System.currentTimeMillis();
Long time = (nowTime - createTime) / 1000;
log.info("没有获取到锁,检测获取锁的线程是否处理超时,超时则释放他的锁");
if (time > 10) {//自定义锁多久自动释放锁
redisTemplate.delete(key);
log.info("逻辑处理超过20秒,释放锁!");
}
}
}
}
//jds
public void twoLock() {
//基于redis的分布式锁
String redisKey = "key-001";
boolean falg = false;
try {
Long lock = this.incrBy(redisKey, 1, 10);//一次,超时时间10秒
if (lock > 1) {
log.info("请勿重复提交请求");
}
log.info("逻辑处理开始。。。。");
} catch (Exception e) {
log.error("#accumulatePoints() 出现异常:{}", e);
} finally {
if(falg) {
this.del(redisKey);
}
}
}
static ShardedJedisPool pool;
public static Long incrBy(String key, long num, int seconds) {
ShardedJedis jds = null;
jds = pool.getResource();
Long result = jds.incrBy(key, num);
if (seconds > 0) {
jds.expire(key, seconds);
}
return result;
}
public static void del(String key) {
ShardedJedis jds = null;
try {
jds = pool.getResource();
jds.del(key);
} catch (Exception e) {
log.error("#RedisPool() del异常:", e);
e.printStackTrace();
}
}
}
package com.redis.mq.util;
import redis.clients.jedis.Jedis;
import java.util.Collections;
import java.util.UUID;
/**
* @author xiaowu
* @date 2019-12-20
**/
public class RedisLock {
/**
* RedisLock的正确姿势
* 加锁:
* 通过setnx 向特定的key写入一个随机数,并设置失效时间,写入成功即加锁成功
* 注意点:
* 必须给锁设置一个失效时间 -----> 避免死锁
* 加锁时,每个节点产生一个随机字符串 -----> 避免锁误删
* 写入随机数与设置失效时间必须是同时 -----> 保证加锁的原子性
* 使用:
* SET key value NX PX 3000
*
* 解锁:
* 匹配随机数,删除redis上的特定的key数据,
* 要保证获取数据,判断一致以及删除数据三个操作是原子性
* 执行如下lua脚本:
* if redis.call('get', KEYS[1]) == ARGV[1] then
* return redis.call('del', KEYS[1])
* else
* return 0
* end
*
*/
// 使用jedis 客户端的
/**SET key value NX PX 3000 成功返回值*/
private static final String LOCK_SUCCESS = "OK";
/**表示 NX 模式*/
private static final String SET_IF_NOT_EXIST = "NX";
/**单位 毫秒**/
private static final String SET_WITH_EXPIRE_TIME_PX = "PX";
/**lua脚本**/
private static final String SCRIPT = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
/**存储随机数**/
private static final ThreadLocal<String> local = new ThreadLocal<>();
/**
* 加锁
*/
public static boolean lock(Jedis jedis, String key, int expireTime) {
// 产生随机数
String uuid = UUID.randomUUID().toString().replaceAll("-", "");
String result = jedis.set(key, uuid, SET_IF_NOT_EXIST, SET_WITH_EXPIRE_TIME_PX, expireTime);
if (LOCK_SUCCESS.equals(result)) {
// 随机数绑定线程
local.set(uuid);
return true;
}
return false;
}
/**
* 释放分布式锁
*/
public static boolean unLock(Jedis jedis, String key) {
String uuid = local.get();
//当前线程没有绑定uuid
//直接返回
if (uuid == null || "".equals(uuid)) {
return false;
}
Object result = jedis.eval(SCRIPT, Collections.singletonList(key), Collections.singletonList(uuid));
if (Long.valueOf(1).equals(result)) {
// 解除绑定线程的随机数
local.remove();
return true;
}
return false;
}
public static void main(String[] args) {
Jedis jedis = new Jedis("localhost", 6379);
jedis.auth("373616885");
jedis.select(0);
final String LOCK_KEY = "LOCK_KEY";
RedisLock.lock(jedis,LOCK_KEY,5000);
RedisLock.unLock(jedis,LOCK_KEY);
}
}