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> RFutureT> tryLockInnerAsync(long waitTime, long leaseTime, TimeUnit unit, long threadId, RedisStrictCommandT> 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));
    }