redis分布式锁的实现原理实例分析

首先,为了确保分布式锁可用,我们至少要确保锁的实现同时满足以下四个条件:

1.互斥性。在任意时刻,只有一个客户端能持有锁。

2.不会发生死锁。即使有一个客户端在持有锁的期间崩溃而没有主动解锁,也能保证后续其他客户端能加锁。

Redis分布式锁的实现原理与实例分析

3.具有容错性。只要大部分的Redis节点正常运行,客户端就可以加锁和解锁。

4.解铃还须系铃人。加锁和解锁必须是同一个客户端,客户端自己不能把别人加的锁给解了。

下边是代码实现,首先我们要通过Maven引入Jedis开源组件,在pom.xml文件加入下面的代码:

<
dependency>

<
groupId>
org.springframework.boot<
/groupId>

<
artifactId>
spring-boot-starter-data-redis<
/artifactId>

<
/dependency>

<
dependency>

<
groupId>
redis.clients<
/groupId>

<
artifactId>
jedis<
/artifactId>

<
version>
3.1.0<
/version>

<
/dependency>

分布式锁实现代码,DistributedLock.java

import redis.clients.jedis.Jedis;

import redis.clients.jedis.JedisPool;

import redis.clients.jedis.JedisPoolConfig;

import redis.clients.jedis.Transaction;

import redis.clients.jedis.exceptions.JedisException;

import java.util.List;

import java.util.UUID;

/**
* @author swadian
* @date 2022/3/4
* @Version 1.0
* @describetion Redis分布式锁原理
*/
public class DistributedLock {
//redis连接池
private static JedisPool jedisPool;

static {
JedisPoolConfig config = new JedisPoolConfig();

// 设置最大连接数
config.setMaxTotal(200);

// 设置最大空闲数
config.setMaxIdle(8);

// 设置最大等待时间
config.setMaxWaitMillis(1000 * 100);

// 在borrow一个jedis实例时,是否需要验证,若为true,则所有jedis实例均是可用的
config.setTestOnBorrow(true);

jedisPool = new JedisPool(config, "
192.168.3.27"
, 6379, 3000);

}
/**
* 加锁
* @param lockName 锁的key
* @param acquireTimeout 获取锁的超时时间
* @param timeout 锁的超时时间
* @return 锁标识
* Redis Setnx(SET if Not eXists) 命令在指定的 key 不存在时,为 key 设置指定的值。
* 设置成功,返回 1 。 设置失败,返回 0 。
*/
public String lockWithTimeout(String lockName, long acquireTimeout, long timeout) {
Jedis jedis = null;

String retIdentifier = null;

try {
// 获取连接
jedis = jedisPool.getResource();

// value值->
随机生成一个String
String identifier = UUID.randomUUID().toString();

// key值->
即锁名
String lockKey = "
lock:"
+ lockName;

// 超时时间->
上锁后超过此时间则自动释放锁 毫秒转成->

int lockExpire = (int) (timeout / 1000);

// 获取锁的超时时间->
超过这个时间则放弃获取锁
long end = System.currentTimeMillis() + acquireTimeout;

while (System.currentTimeMillis() <
end) { //在获取锁时间内
if (jedis.setnx(lockKey, identifier) == 1) {//关键:设置锁
jedis.expire(lockKey, lockExpire);

// 返回value值,用于释放锁时间确认
retIdentifier = identifier;

return retIdentifier;

}
// ttl以秒为单位返回 key 的剩余过期时间,返回-1代表key没有设置超时时间,为key设置一个超时时间
if (jedis.ttl(lockKey) == -1) {
jedis.expire(lockKey, lockExpire);

}
try {
Thread.sleep(10);

} catch (InterruptedException e) {
Thread.currentThread().interrupt();

}
}
} catch (JedisException e) {
e.printStackTrace();

} finally {
if (jedis != null) {
jedis.close();

}
}
return retIdentifier;

}
/**
* 释放锁
* @param lockName 锁的key
* @param identifier 释放锁的标识
* @return
*/
public boolean releaseLock(String lockName, String identifier) {
Jedis jedis = null;

String lockKey = "
lock:"
+ lockName;

boolean retFlag = false;

try {
jedis = jedisPool.getResource();

while (true) {
// 监视lock,准备开始redis事务
jedis.watch(lockKey);

// 通过前面返回的value值判断是不是该锁,若是该锁,则删除,释放锁
if (identifier.equals(jedis.get(lockKey))) {
Transaction transaction = jedis.multi();
//开启redis事务
transaction.del(lockKey);

List<
Object>
results = transaction.exec();
//提交redis事务
if (results == null) {//提交失败
continue;
//继续循环
}
retFlag = true;
//提交成功
}
jedis.unwatch();
//解除监控
break;

}
} catch (JedisException e) {
e.printStackTrace();

} finally {
if (jedis != null) {
jedis.close();

}
}
return retFlag;

}
}

为了验证它,我们创建SkillService.java业务类

import lombok.extern.slf4j.Slf4j;

@Slf4j
public class SkillService {
final DistributedLock lock = new DistributedLock();

public static final String LOCK_KEY = "
lock_resource"
;

int n = 500;

/**
* 线程业务方法
*/
public void seckill() {
// 返回锁的value值,供释放锁时候进行判断
String identifier = lock.lockWithTimeout(LOCK_KEY, 5000, 1000);

log.info("
线程:"
+Thread.currentThread().getName() + "
获得了锁"
);

log.info("
剩余数量:{}"
,--n);

lock.releaseLock(LOCK_KEY, identifier);

}
}

如果找不到@Slf4j日志,在pom.xml文件加入下面的代码:

<
!--@Slf4j日志依赖组件-->

<
dependency>

<
groupId>
org.projectlombok<
/groupId>

<
artifactId>
lombok<
/artifactId>

<
/dependency>

编辑一个测试类TestLock.java

/**
* @author swadian
* @date 2022/3/4
* @Version 1.0
*/
public class TestLock {
public static void main(String[] args) {
SkillService service = new SkillService();

for (int i = 10;
i <
60;
i++) { //开50个线程
SkillThread skillThread = new SkillThread(service, "
skillThread->
"
+ i);

skillThread.start();

}
}
}
class SkillThread extends Thread {
private SkillService skillService;

public SkillThread(SkillService skillService, String skillThreadName) {
super(skillThreadName);

this.skillService = skillService;

}
@Override
public void run() {
skillService.seckill();

}
}

测试结果显示,加锁后剩余数量全部是顺序串行的,499,498,497...

我们修改SkillService.java业务类,注释掉加锁逻辑

@Slf4j
public class SkillService {
final DistributedLock lock = new DistributedLock();

public static final String LOCK_KEY = "
lock_resource"
;

int n = 500;

/**
* 线程业务方法
*/
public void seckill() {
// 返回锁的value值,供释放锁时候进行判断
//String identifier = lock.lockWithTimeout(LOCK_KEY, 5000, 1000);

log.info("
线程:"
+Thread.currentThread().getName() + "
获得了锁"
);

log.info("
剩余数量:{}"
,--n);

//lock.releaseLock(LOCK_KEY, identifier);

}
}

重新执行测试,注释掉加锁逻辑后,剩余数量全部是乱序的,472,454,452...



一、Redis分布式锁的原理
Redis作为一种内存Key-Value存储型数据库,常用作数据缓存和分布式锁的实现。Redis分布式锁主要是通过SETNX、EXPIRE、DEL三个命令来实现的。
1. SETNX命令:尝试将key的值设为value,如果key不存在,那么执行SET操作,如果key已经存在,则不做任何操作。SETNX的返回值为1时表示设置成功,返回0则表示设置失败。
2. EXPIRE命令:为给定key设置过期时间。
3. DEL命令:用于删除已存在的键。如果key不存在,则不做任何操作。
二、Redis分布式锁的实例分析
1. 基于Redis分布式锁的分布式系统
假设有一个分布式系统,需要对某一任务进行加锁处理。由于该系统分散在不同的服务器上,需要实现一个能够在不同服务器之间共同使用的锁机制。
2. 加锁操作
我们需要先获取锁,首先使用SETNX命令在Redis中添加锁对应的key-value,如果返回值为1,则表示加锁成功。然后使用EXPIRE命令为该key设置一个过期时间,防止出现异常情况下无法释放锁的情况。在加锁成功后,返回锁的唯一标识给调用者。
3. 释放锁操作
我们需要通过DEL命令将锁对应的key和value删除,以确保锁的释放。在释放锁后,还需要将锁的唯一标识发给其他等待锁的进程或线程以获得锁,完成锁的传递。
三、总结
Redis分布式锁采用分布式架构,能够有效地保证不同服务器之间对于同一任务进行互斥访问。通过SETNX、EXPIRE、DEL三个命令实现加锁和释放锁操作,确保了加锁和释放锁过程的原子性和一致性。在实际应用中,需要对加锁和释放锁的异常情况进行处理,以保证分布式锁的稳定性和安全性。