Redisson信号量到期未得到遵守

我正在使用Redisson来同步我们的API。以下是我正在使用的

方面

：

@Aspect
@Component
@Slf4j
public class SerialiseRequestsOnDistributedMutexAspect {

  private final String lockOn = "LockOn";

  @Autowired(required = false)
  RedissonClient client;

  @Around("@annotation(somepath)")
  @SuppressWarnings("unchecked")
  public DeferredResult<ResponseEntity<?>> controllerProxy(ProceedingJoinPoint pjp)
      throws Throwable {

    try {

      Long startTime = System.currentTimeMillis();

      //extract parameters from the request
      Map<String, String> parameters = getParameters(pjp);
      
      //the semaphore key
      String lockOn = parameters.get(this.lockOn);
      
      RPermitExpirableSemaphore semaphore = client.getPermitExpirableSemaphore(lockOn);

      semaphore.trySetPermits(1);

      DeferredResult<ResponseEntity<?>> dr;

      MDC.clear();

      String permitId = getPermit(semaphore);

      if (null != permitId) {

        semaphore.updateLeaseTime(
            permitId, 60_000l, TimeUnit.MILLISECONDS);
        semaphore.expire(60_000l, TimeUnit.MILLISECONDS);

        try {
          Object result = pjp.proceed();
          dr = (DeferredResult<ResponseEntity<?>>) result;
          addCallbacksOnDeferredResult(dr, semaphore);
        } catch (Exception e) {
          semaphore.release(permitId);
          throw e;
        }
      } else {
        throw new RuntimeException("Similar request in progress");
      }
      return dr;
    } catch (Exception e) {
      throw e;
    }
  }

  private String getPermit(RPermitExpirableSemaphore semaphore) {
    return semaphore.tryAcquire();
  }

  private void addCallbacksOnDeferredResult(
      DeferredResult<ResponseEntity<?>> dr,
      RPermitExpirableSemaphore lock) {
    dr.onCompletion(
        () -> {
          MDC.clear();
          lock.release(requestMetadata.permitId());
        });
    dr.onTimeout(
        () -> {
          MDC.clear();
          lock.release(requestMetadata.permitId());
        });
    dr.onError(
        (err) -> {
          MDC.clear();
          lock.release(requestMetadata.permitId());
        });
  }

}

@方面
@组成部分
@Slf4j
公共类SerialiserRequestsOnDistributedMuteSpect{
私有最终字符串lockOn=“lockOn”；
@自动连线（必需=错误）
再贴现客户机；
@周围（“@annotation（somepath）”）
@抑制警告（“未选中”）
公共延迟结果>dr；
MDC.clear（）；
字符串permitId=getPermit（信号量）；
如果（null！=permitId）{
semaphore.updateLaseTime(
permitId，60_000l，时间单位为毫秒）；
信号量过期（60_000l，时间单位毫秒）；
试一试{
对象结果=pjp.procedure（）；
dr=（延迟结果>dr，
rpermitexpirable信号量锁）{
onCompletion博士(
() -> {
MDC.clear（）；
lock.release（requestMetadata.permitId（））；
});
onTimeout博士(
() -> {
MDC.clear（）；
lock.release（requestMetadata.permitId（））；
});
奥内罗博士(
（呃）->{
MDC.clear（）；
lock.release（requestMetadata.permitId（））；
});
}
}

我观察到某些情况下，Redis中的

LockOn

对象的

TTL

设置为-1。这意味着没有

TTL

。但在成功收购时，我明确地将其设置为

60s

。我是做错了什么，还是这是Redisson的一个错误？这只发生在一些调用中s、 这些请求永远被卡住了