//设置锁1秒过去
redissonLock.lock("redisson", 1);
/**
 * 业务逻辑需要咨询2秒
*/
redissonLock.release("redisson");

/**
 * 线程1 进来获得锁后，线程一切正常并没有宕机，但它的业务逻辑需要执行2秒，这就会有个问题，在 线程1 执行1秒后，这个锁就自动过期了，
 * 那么这个时候 线程2 进来了。那么就存在 线程1和线程2 同时在这段业务逻辑里执行代码，这当然是不合理的。
 * 而且如果是这种情况，那么在解锁时系统会抛异常，因为解锁和加锁已经不是同一线程了，具体后面代码演示。
*/

@Autowired
private RedissonClient redissonClient;
RLock lock = redissonClient.getLock(objId + lockSuffix);

public RLock getLock(String name) {
    return new RedissonLock(this.connectionManager.getCommandExecutor(), name);
}

public RedissonLock(CommandAsyncExecutor commandExecutor, String name) {
    super(commandExecutor, name);
    this.commandExecutor = commandExecutor;
    this.id = commandExecutor.getConnectionManager().getId();
    this.internalLockLeaseTime = commandExecutor.getConnectionManager().getCfg().getLockWatchdogTimeout();
    this.entryName = this.id + ":" + name;
}

isSuccess = lock.tryLock(5, 5, TimeUnit.SECONDS);

public boolean tryLock(long waitTime, long leaseTime, TimeUnit unit) throws InterruptedException {
       long time = unit.toMillis(waitTime);
       long current = System.currentTimeMillis();
       final long threadId = Thread.currentThread().getId();
       Long ttl = this.tryAcquire(leaseTime, unit, threadId); // 加锁
       if (ttl == null) {
           return true;
       } else {
       }
}

private Long tryAcquire(long leaseTime, TimeUnit unit, long threadId) {
    return (Long)this.get(this.tryAcquireAsync(leaseTime, unit, threadId));
}

private <T> RFuture<Long> tryAcquireAsync(long leaseTime, TimeUnit unit, final long threadId) {
    if (leaseTime != -1L) {
        return this.tryLockInnerAsync(leaseTime, unit, threadId, RedisCommands.EVAL_LONG); // 
    } else {
        RFuture<Long> ttlRemainingFuture = this.tryLockInnerAsync(this.commandExecutor.getConnectionManager().getCfg().getLockWatchdogTimeout(), TimeUnit.MILLISECONDS, threadId, RedisCommands.EVAL_LONG);
        ttlRemainingFuture.addListener(new FutureListener<Long>() {
            public void operationComplete(Future<Long> future) throws Exception {
                if (future.isSuccess()) {
                    Long ttlRemaining = (Long)future.getNow();
                    if (ttlRemaining == null) {
                        RedissonLock.this.scheduleExpirationRenewal(threadId);
                    }

                }
            }
        });
        return ttlRemainingFuture;
    }
}

<T> RFuture<T> tryLockInnerAsync(long leaseTime, TimeUnit unit, long threadId, RedisStrictCommand<T> command) {
    this.internalLockLeaseTime = unit.toMillis(leaseTime);
    return this.commandExecutor.evalWriteAsync(this.getName(), LongCodec.INSTANCE, command, "if (redis.call('exists', KEYS[1]) == 0) then redis.call('hset', 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(this.getName()), new Object[]{this.internalLockLeaseTime, this.getLockName(threadId)});
}

public <T, R> RFuture<R> evalWriteAsync(String key, Codec codec, RedisCommand<T> evalCommandType, String script, List<Object> keys, Object... params) {
    NodeSource source = this.getNodeSource(key);
    return this.evalAsync(source, false, codec, evalCommandType, script, keys, params);
}

protected <V, R> void async(boolean readOnlyMode, final NodeSource source, Codec codec, final RedisCommand<V> command, final Object[] params, RPromise<R> mainPromise, int attempt, final boolean ignoreRedirect, final RFuture<RedisConnection> connFuture) {
    CommandAsyncService.this.sendCommand(details, connection);
}

try {
} catch (Exception e){
} finally {
   lock.unlock(); // 记得释放锁
}

@Configuration
@ComponentScan
public class RedissonConfig {
    @Bean(name = "redissonRedisProperties")
    @ConfigurationProperties("redis.default")
    public RedisProperties defaultRedisProperties() {
        return new RedisProperties();
    }
    @Bean(value = "redissonClient", destroyMethod = "shutdown")
    RedissonClient redisson(@Qualifier("redissonRedisProperties") RedisProperties redisProperties) throws IOException {
        Config config = new Config();
        config.useClusterServers()
                .setMasterConnectionPoolSize(redisProperties.getMaxIdle())
                .setMasterConnectionMinimumIdleSize(redisProperties.getMinIdle())
                .setConnectTimeout(redisProperties.getConnectionTimeout())
                .addNodeAddress(redisProperties.getNodes().stream().map(n -> "redis://" + n).toArray(String[]::new));
        return Redisson.create(config);
    }
}

@Service
@Slf4j
public class DpaBaseService {

    @Autowired
    private RedissonClient redissonClient;

    public RLock getLock(Object objId, String lockSuffix) {
        RLock lock = redissonClient.getLock(objId + lockSuffix);
        boolean isSuccess;
        try {
            isSuccess = lock.tryLock(5, 5, TimeUnit.SECONDS);
            log.info(System.currentTimeMillis() + "isSuccess: " + isSuccess + "---getLock----" + Thread.currentThread().getName());
        } catch (InterruptedException e) {
            log.error("rLock.tryLock.e", e);
            isSuccess = false;
            log.info(System.currentTimeMillis() + "---getLock false----" + Thread.currentThread().getName());
            Thread.currentThread().interrupt();
        }
        Assert.isTrue(isSuccess, "资源正在被其他人编辑，请稍后重试");
        return lock;
    }
}

RLock lock = dpaBaseService.getLock(blackDpaDto.getId(), Constants.BLACK_DPA_LOCK_PREFIX);
try {
    return blackDpaServiceDelegate.updateBlackDpa(operator, blackDpaDto);
} finally {
    log.info(System.currentTimeMillis() + "---update black dpa unLock----");
    lock.unlock();
}