<dependency>
  <groupId>org.redisson</groupId>
  <artifactId>redisson-spring-boot-starter</artifactId>
  <version>3.16.4</version>
</dependency>

redis:
  host: xxxxxxx
  password: xxxxxx
  max-active: 8
  max-idle: 500
  max-wait: 1
  min-idle: 0
  port: 6379
  timeout: 1000ms
  database: 0

@Configuration
public class RedisConfig {
   //最簡(jiǎn)單的redisson初始化配置
    @Bean
    public RedissonClient getRedisson() {
        Config config = new Config();
        config.useSingleServer().setAddress("redis://" + host + ":" + port).setPassword(password);
        return Redisson.create(config);
    }
}

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface RedisLock {
    //鎖的名稱
    String lockName();
    //鎖的失效時(shí)間
    long leaseTime() default 3;
    //是否開(kāi)啟看門狗，默認(rèn)開(kāi)啟，開(kāi)啟時(shí)鎖的失效時(shí)間不執(zhí)行。任務(wù)未完成時(shí)會(huì)自動(dòng)續(xù)期鎖時(shí)間
    //使用看門狗，鎖默認(rèn)redis失效時(shí)間未30秒。失效時(shí)間剩余1/3時(shí)進(jìn)行續(xù)期判斷，是否需要續(xù)期
    boolean watchdog() default true;
}

public class RedisLockAspect {
    @Autowired
    private RedissonClient redissonClient;
 
    private static final String REDIS_PREFIX = "redisson_lock:";
 
    @Around("@annotation(redisLock)")
    public Object around(ProceedingJoinPoint joinPoint, RedisLock redisLock) throws Throwable {
        String lockName = redisLock.lockName();
 
        RLock rLock = redissonClient.getLock(REDIS_PREFIX + lockName);
 
        Object result = null;
        boolean isLock;
        if(redisLock.watchdog()){
            isLock =rLock.tryLock(0, TimeUnit.SECONDS);
        }else {
            isLock =rLock.tryLock(0,redisLock.leaseTime(), TimeUnit.SECONDS);
        }
        if(isLock){
            try {
                //執(zhí)行方法
                result = joinPoint.proceed();
            } finally {
                if (rLock.isLocked() && rLock.isHeldByCurrentThread()) {
                    rLock.unlock();
                }
            }
        }else {
            log.warn("The lock has been taken:{}",REDIS_PREFIX + lockName);
        }
        return result;
    }
}

@Scheduled(cron = "*/10 * * * * ?")
    //使用注解進(jìn)行加鎖
    @RedisLock(lockName = "npa_lock_test",watchdog = true)
    public void redisLockTest() {
     System.out.println("get lock and perform a task");
        try {
            Thread.sleep(20000L);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

private <T> RFuture<Long> tryAcquireAsync(long waitTime, long leaseTime, TimeUnit unit, long threadId) {
        RFuture<Long> ttlRemainingFuture;
        //如果指定了加鎖時(shí)間，會(huì)直接去加鎖
        if (leaseTime != -1) {
            ttlRemainingFuture = tryLockInnerAsync(waitTime, leaseTime, unit, threadId, RedisCommands.EVAL_LONG);
        } else {
            //沒(méi)有指定加鎖時(shí)間 會(huì)先進(jìn)行加鎖，并且默認(rèn)時(shí)間就是 LockWatchdogTimeout的時(shí)間
            //這個(gè)是異步操作 返回RFuture 類似netty中的future
            ttlRemainingFuture = tryLockInnerAsync(waitTime, internalLockLeaseTime,
                    TimeUnit.MILLISECONDS, threadId, RedisCommands.EVAL_LONG);
        }
 
        //這里也是類似netty Future 的addListener，在future內(nèi)容執(zhí)行完成后執(zhí)行
        ttlRemainingFuture.onComplete((ttlRemaining, e) -> {
            if (e != null) {
                return;
            }
 
            // lock acquired
            if (ttlRemaining == null) {
                // leaseTime不為-1時(shí)，不會(huì)自動(dòng)延期
                if (leaseTime != -1) {
                    internalLockLeaseTime = unit.toMillis(leaseTime);
                } else {
                    //這里是定時(shí)執(zhí)行 當(dāng)前鎖自動(dòng)延期的動(dòng)作,leaseTime為-1時(shí)，才會(huì)自動(dòng)延期
                    scheduleExpirationRenewal(threadId);
                }
            }
        });
        return ttlRemainingFuture;
    }

private void renewExpiration() {
        ExpirationEntry ee = EXPIRATION_RENEWAL_MAP.get(getEntryName());
        if (ee == null) {
            return;
        }
 
        Timeout task = commandExecutor.getConnectionManager().newTimeout(new TimerTask() {
            @Override
            public void run(Timeout timeout) throws Exception {
                ExpirationEntry ent = EXPIRATION_RENEWAL_MAP.get(getEntryName());
                if (ent == null) {
                    return;
                }
                Long threadId = ent.getFirstThreadId();
                if (threadId == null) {
                    return;
                }
 
                RFuture<Boolean> future = renewExpirationAsync(threadId);
                future.onComplete((res, e) -> {
                    if (e != null) {
                        log.error("Can't update lock " + getRawName() + " expiration", e);
                        EXPIRATION_RENEWAL_MAP.remove(getEntryName());
                        return;
                    }
 
                    if (res) {
                        //如果 沒(méi)有報(bào)錯(cuò)，就再次定時(shí)延期
                        // reschedule itself
                        renewExpiration();
                    } else {
                        cancelExpirationRenewal(null);
                    }
                });
            }
            // 這里我們可以看到定時(shí)任務(wù) 是 lockWatchdogTimeout 的1/3時(shí)間去執(zhí)行 renewExpirationAsync
        }, internalLockLeaseTime / 3, TimeUnit.MILLISECONDS);
 
        ee.setTimeout(task);
    }

protected RFuture<Boolean> renewExpirationAsync(long threadId) {
        return this.evalWriteAsync(this.getRawName(), LongCodec.INSTANCE, RedisCommands.EVAL_BOOLEAN, "if (redis.call('hexists', KEYS[1], ARGV[2]) == 1) then redis.call('pexpire', KEYS[1], ARGV[1]); return 1; end; return 0;", Collections.singletonList(this.getRawName()), this.internalLockLeaseTime, this.getLockName(threadId));
    }