redis分布式锁之可重入锁的实现代码

import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.locks.ReentrantLock;

@Slf4j
public class ReentrantLockDemo {
//锁
private static ReentrantLock lock = new ReentrantLock();
public void doSomething(int n){
try{
//进入递归第一件事：加锁
lock.lock();
log.info(“——–lock()执行后，getState()的值：{} lock.isLocked():{}”,lock.getHoldCount(),lock.isLocked());
log.info(“——–递归{}次——–“,n);
if(n<=2){
this.doSomething(++n);
}else{
return;
}
}finally {
lock.unlock();
log.info(“——–unlock()执行后，getState()的值：{} lock.isLocked():{}”,lock.getHoldCount(),lock.isLocked());
}
}

public static void main(String[] args) {
ReentrantLockDemo reentrantLockDemo=new ReentrantLockDemo();
reentrantLockDemo.doSomething(1);
log.info(“执行完doSomething方法 是否还持有锁：{}”,lock.isLocked());
}

}

final boolean nonfairTryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
//先判断，c（state）是否等于0，如果等于0，说明没有线程持有锁
if (c == 0) {
//通过cas方法把state的值0替换成1，替换成功说明加锁成功
if (compareAndSetState(0, acquires)) {
//如果加锁成功，设置持有锁的线程是当前线程
setExclusiveOwnerThread(current);
return true;
}
}
else if (current == getExclusiveOwnerThread()) {//判断当前持有锁的线程是否是当前线程
//如果是当前线程，则state值加acquires，代表了当前线程加锁了多少次
int nextc = c + acquires;
if (nextc < 0) // overflow
throw new Error(“Maximum lock count exceeded”);
setState(nextc);
return true;
}
return false;
}

/**
* 释放锁
* @param releases
* @return
*/
protected final boolean tryRelease(int releases) {
int c = getState() – releases;//state-1 减加锁次数
//如果持有锁的线程，不是当前线程，抛出异常
if (Thread.currentThread() != getExclusiveOwnerThread())
throw new IllegalMonitorStateException();

boolean free = false;
if (c == 0) {//如果c==0了说明当前线程，已经要释放锁了
free = true;
setExclusiveOwnerThread(null);//设置当前持有锁的线程为null
}
setState(c);//设置c的值
return free;
}

<dependency>
<groupId>org.redisson</groupId>
<artifactId>redisson</artifactId>
<version>3.15.5</version>
</dependency>

import lombok.extern.slf4j.Slf4j;
import org.redisson.Redisson;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.redisson.config.SingleServerConfig;

@Slf4j
public class ReentrantLockDemo1 {
//锁
public static RLock lock;

static {
//Redisson需要的配置
Config config = new Config();
String node = “127.0.0.1:6379”;//redis地址
node = node.startsWith(“redis://”) ? node : “redis://” + node;
SingleServerConfig serverConfig = config.useSingleServer()
.setAddress(node)
.setTimeout(3000)//超时时间
.setConnectionPoolSize(10)
.setConnectionMinimumIdleSize(10);
//serverConfig.setPassword(“123456”);//设置redis密码
// 创建RedissonClient客户端实例
RedissonClient redissonClient = Redisson.create(config);
//创建redisson的分布式锁
RLock rLock = redissonClient.getLock(“666”);
lock = rLock;
}
public void doSomething(int n){
try{
//进入递归第一件事：加锁
lock.lock();
log.info(“——–lock()执行后，getState()的值：{} lock.isLocked():{}”,lock.getHoldCount(),lock.isLocked());
log.info(“——–递归{}次——–“,n);
if(n<=2){
this.doSomething(++n);
}else{
return;
}
}finally {
lock.unlock();
log.info(“——–unlock()执行后，getState()的值：{} lock.isLocked():{}”,lock.getHoldCount(),lock.isLocked());
}
}
public static void test(){
log.info(“————–start—————“);
ReentrantLockDemo1 reentrantLockDemo=new ReentrantLockDemo1();
reentrantLockDemo.doSomething(1);
log.info(“执行完doSomething方法 是否还持有锁：{}”,ReentrantLockDemo1.lock.isLocked());
log.info(“————–end—————“);
}
public static void main(String[] args) {
test();
}
}

<T> RFuture<T> tryLockInnerAsync(long waitTime, long leaseTime, TimeUnit unit, long threadId, RedisStrictCommand<T> command) {
return evalWriteAsync(getRawName(), LongCodec.INSTANCE, command,
“if (redis.call(‘exists’, KEYS[1]) == 0) then ” +
“redis.call(‘hincrby’, KEYS[1], ARGV[2], 1); ” +
“redis.call(‘pexpire’, KEYS[1], ARGV[1]); ” +
“return nil; ” +
“end; ” +
“if (redis.call(‘hexists’, KEYS[1], ARGV[2]) == 1) then ” +
“redis.call(‘hincrby’, KEYS[1], ARGV[2], 1); ” +
“redis.call(‘pexpire’, KEYS[1], ARGV[1]); ” +
“return nil; ” +
“end; ” +
“return redis.call(‘pttl’, KEYS[1]);”,
Collections.singletonList(getRawName()), unit.toMillis(leaseTime), getLockName(threadId));
}

protected String getLockName(long threadId) {
return id + “:” + threadId;
}

return evalWriteAsync(getRawName(), LongCodec.INSTANCE, RedisCommands.EVAL_BOOLEAN,
“if (redis.call(‘hexists’, KEYS[1], ARGV[3]) == 0) then ” +
“return nil;” +
“end; ” +
“local counter = redis.call(‘hincrby’, KEYS[1], ARGV[3], -1); ” +
“if (counter > 0) then ” +
“redis.call(‘pexpire’, KEYS[1], ARGV[2]); ” +
“return 0; ” +
“else ” +
“redis.call(‘del’, KEYS[1]); ” +
“redis.call(‘publish’, KEYS[2], ARGV[1]); ” +
“return 1; ” +
“end; ” +
“return nil;”,
Arrays.asList(getRawName(), getChannelName()), LockPubSub.UNLOCK_MESSAGE, internalLockLeaseTime, getLockName(threadId));
}