【redis】——分布式锁

关注

原创最新推荐文章于 2026-06-06 13:18:03 发布 226 阅读 AI 写同款· GEO 优化 ›

Redis实战之 分布式锁 重入问题：重入问题是指获得锁的线程可以再次进入到相同的锁的代码块中，可重入锁的意义在于防止死锁，比如HashTable这样的代码中，他的方法都是使用synchronized修饰的，假如他在一个方法内，调用另一个方法，那么此时如果是不可重入的，不就死锁了吗？所以可重入锁他的主要意义是防止死锁，我们的synchronized和Lock锁都是可重入的。不可重试：是指目前的分布式只能尝试一次，我们认为合理的情况是：当线程在获得锁失败后，他应该能再次尝试获得锁。阅读详情

原创hy_coming 最后发布于2019-07-07 16:56:10 阅读数 33 已收藏
展开
实例代码地址，请前往：https://gitee.com/GuoqingLee/distributed-seckill

redis官方文档地址，请前往：http://www.redis.cn/topics/distlock.html

前言
关于分布式锁的实现，目前主流方案有以下三类：

1、基于数据库的乐观锁；

2、基于redis实现的锁服务；

3、基于zookeeper的实现；

本文注释基于redis实现分布式锁，一种是最普通的实现方式，另外一种是redis官网推荐的实现方式redission实现，接下看看实现代码

一、普通实现方式
普通实现方式是基于以下两个命令

#使用redis中的setnx命令创建一个key，成功创建就是加锁
SET resource_name my_random_value NX PX 30000

#删除锁的时候，找到 key 对应的 value，跟自己传过去的 value 做比较，如果是一样的才删除。
if redis.call("get",KEYS[1]) == ARGV[1] then
return redis.call("del",KEYS[1])
else
return 0
end
依赖引入

<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
</dependency>
代码实现

/**
* @author 2019/7/7 15:49
*/
public class RedisLocker {
@Autowired
private JedisPool jedisPool;

/**
* 获取锁
*
* @param key
* @param value
* @param leaseTime 过期时间
* @return
*/
public boolean tryLock(String key, String value, long leaseTime) {
try (Jedis jedis = jedisPool.getResource()) {
if (jedis == null) {
return false;
}
String result = jedis.set(key, value, "NX", "PX", leaseTime);
return "OK".equalsIgnoreCase(result);
} catch (Exception e) {
return false;
}
}

/**
* 释放锁
* @param key
* @param value
* @return
*/
public int unlock(String key, String value) {
try (Jedis jedis = jedisPool.getResource()) {
if (jedis == null) {
return 0;
}
StringBuilder builder = new StringBuilder();
builder.append("if redis.call('get','")
.append(key)
.append("')")
.append("=='")
.append(" then ")
.append(" return redis.call('del','")
.append(key)
.append("')")
.append(" else ")
.append(" return 0")
.append(" end");
return Integer.valueOf(jedis.eval(builder.toString()).toString());
}catch (Exception e){
return 0;
}
}

}
结果请自行测试

二、基于redission实现
依赖引入

<dependency>
<groupId>org.redisson</groupId>
<artifactId>redisson-spring-boot-starter</artifactId>
<version>3.10.1</version>
</dependency>
配置文件

#redis config
spring.redis.database=
spring.redis.host=
spring.redis.port=
spring.redis.password=
spring.redis.ssl=
spring.redis.timeout=
spring.redis.cluster.nodes=
spring.redis.sentinel.master=
spring.redis.sentinel.nodes=
代码实现

/**
* 基于redission的分布式实现
*
* @author 2019/7/7 15:20
*/
@Component
public class RedissonDistributedLocker {
@Autowired
private RedissonClient redissonClient;

/**
* 加锁
*
* @param lockKey
* @return
*/
public RLock lock(String lockKey) {
RLock lock = redissonClient.getLock(lockKey);
lock.lock();
return lock;
}

/**
* 加锁，过期自动释放
*
* @param lockKey
* @param leaseTime
* @return
*/
public RLock lock(String lockKey, long leaseTime) {
RLock lock = redissonClient.getLock(lockKey);
lock.lock(leaseTime, TimeUnit.SECONDS);
return lock;
}

/**
* 加锁，过期自动释放，传入时间单位
*
* @param lockKey
* @param leaseTime
* @param unit
* @return
*/
public RLock lock(String lockKey, long leaseTime, TimeUnit unit) {
RLock lock = redissonClient.getLock(lockKey);
lock.lock(leaseTime, unit);
return lock;
}

/**
* 尝试获取锁，传入时间单位
*
* @param lockKey
* @param unit
* @param waitTime
* @param leaseTime
* @return
*/
public boolean tryLock(String lockKey, TimeUnit unit, long waitTime, long leaseTime) {
RLock lock = redissonClient.getLock(lockKey);
try {
return lock.tryLock(waitTime, leaseTime, unit);
} catch (InterruptedException e) {
return false;
}
}

/**
* 尝试获取锁
*
* @param lockKey
* @param waitTime
* @param leaseTime
* @return
*/
public boolean tryLock(String lockKey, long waitTime, long leaseTime) {
RLock lock = redissonClient.getLock(lockKey);
try {
return lock.tryLock(waitTime, leaseTime, TimeUnit.SECONDS);
} catch (InterruptedException e) {
return false;
}
}

/**
* 释放锁，传入key
*
* @param lockKey
*/
public void unlock(String lockKey) {
redissonClient.getLock(lockKey).unlock();
}

/**
* 释放锁，传入lock
*
* @param lock
*/
public void unlock(RLock lock) {
lock.unlock();
}
}
结果测试

#方式一
@Autowired
private RedissonDistributedLocker redissonDistributedLocker;

String lockKey = "BM_MARKET_SECKILL_" + stallActivityId;
try {
//超过2S自动释放锁
redissonDistributedLocker.lock(lockKey, 2L);
//业务处理

} finally {
redissonDistributedLocker.unlock(lockKey); //释放锁
}

#方式二
@Autowired
private RedissonDistributedLocker redissonDistributedLocker;

public void test() throws InterruptedException {
final int[] counter = {0};

for (int i= 0; i < 100; i++){

new Thread(new Runnable() {

@Override

public void run() {
boolean isGetLock = redissonDistributedLocker.tryLock("test0001", 3L, 1L);
if(isGetLock) {
try {
int a = counter[0];
counter[0] = a + 1;
logger.info(a + "");
} finally {
redissonDistributedLocker.unlock("test0001");
}
}
}
}).start();

}

// 主线程休眠，等待结果
Thread.sleep(5000);
System.out.println(counter[0]);
logger.info(counter[0] + "");
}
三、redis 分布式锁和 zk 分布式锁的对比
redis 分布式锁，其实需要自己不断去尝试获取锁，比较消耗性能。
zk 分布式锁，获取不到锁，注册个监听器即可，不需要不断主动尝试获取锁，性能开销较小。
另外一点就是，如果是 redis 获取锁的那个客户端出现 bug 挂了，那么只能等待超时时间之后才能释放锁；而 zk 的话，因为创建的是临时 znode，只要客户端挂了，znode 就没了，此时就自动释放锁。