Java 当两个未来完成时，如何释放信号量？

我有一个Springboot java应用程序，它可以与cassandra数据库通信，还可以使用google guava库

目前我面临一个问题。代码中有一个信号量对象

在我的方法中，我必须使用两个对象（mapper和parameterisedListMsisdnMapper）模拟执行两个写查询

使用映射器触发每个查询将返回ListenableFuture和ListenableFuture future1对象。如何重写下面的代码，以便在完成future和future1对象后释放信号量

public class ParameterisedListItemRepository {
        
        public ParameterisedListItemRepository() {
         this.executor = MoreExecutors.directExecutor();
         this.semaphore = new Semaphore(getNumberOfRequests(session));
        }
       
       public void saveAsync(ParameterisedListItem parameterisedListItem) {
           try {
             semaphore.acquire();
             ListenableFuture<Void> future = mapper.saveAsync(parameterisedListItem);
             ListenableFuture<Void> future1 = parameterisedListMsisdnMapper.saveAsync( mapParameterisedList(parameterisedListItem));
             future.addListener(() -> semaphore.release(), executor);
            } catch (InterruptedException e) {
                        throw new RuntimeException("Semaphore was interrupted.");
            }
       }
    
    }

公共类参数化ListItemRepository{
公共参数化ListItemRepository（）{
this.executor=morexecutors.directExecutor（）；
this.semaphore=新信号量（getNumberOfRequests（会话））；
}
public void saveAsync（ParameterizedListItem ParameterizedListItem）{
试一试{
semaphore.acquire（）；
ListenableFuture future=mapper.saveAsync（ParameterizedListItem）；
ListenableFuture1=ParameterizedListMsisdnMapper.saveAsync（MapParameterizedList（ParameterizedListItem））；
future.addListener（（）->semaphore.release（），executor）；
}捕捉（中断异常e）{
抛出新的RuntimeException（“信号量被中断”）；
}
}
}

---

感谢您的帮助

我曾经使用过Futures.when，它成功了

  public void saveAsync(ParameterisedListItem parameterisedListItem) {
        if (parameterisedListItem.getId() == null) {
            parameterisedListItem.setId(UUID.randomUUID());
        }
        Set<ConstraintViolation<ParameterisedListItem>> violations = validator.validate(parameterisedListItem);
        if (violations != null && !violations.isEmpty()) {
            throw new ConstraintViolationException(violations);
        }

        Callable releasePermit = () -> { semaphore.release();
            return null;
        };
        
        try {
            semaphore.acquire();
            ListenableFuture<Void> future1 = mapper.saveAsync(parameterisedListItem);
            ListenableFuture<Void> future2 = parameterisedListMsisdnMapper.saveAsync( mapParameterisedList(parameterisedListItem));
            Futures.whenAllSucceed(future1, future2).call(releasePermit, executor);

        } catch (InterruptedException e) {
            //FIXME handle exception in better way
            throw new RuntimeException("Semaphore was interrupted.");
        }
    }

public void saveAsync（ParameterizedListItem ParameterizedListItem）{
if（ParameterizedListItem.getId（）==null）{
参数化ListItem.setId（UUID.randomUUID（））；
}
设置冲突=validator.validate（ParameterizedListItem）；
if（inflictions！=null&！inflictions.isEmpty（））{
抛出新的ConstraintViolationException（违规）；
}
可调用的releasePermit=（）->{semaphore.release（）；
返回null；
};
试一试{
semaphore.acquire（）；
ListenableFuture1=mapper.saveAsync（ParameterizedListItem）；
ListenableFuture2=参数化ListMsisdnMapper.saveAsync（MapParameterizedList（ParameterizedListItem））；
期货。何时成功（未来1，未来2）。调用（释放许可证，执行人）；
}捕捉（中断异常e）{
//FIXME以更好的方式处理异常
抛出新的RuntimeException（“信号量被中断”）；
}
}

我使用了Futures.when，它成功了，并且起了作用

  public void saveAsync(ParameterisedListItem parameterisedListItem) {
        if (parameterisedListItem.getId() == null) {
            parameterisedListItem.setId(UUID.randomUUID());
        }
        Set<ConstraintViolation<ParameterisedListItem>> violations = validator.validate(parameterisedListItem);
        if (violations != null && !violations.isEmpty()) {
            throw new ConstraintViolationException(violations);
        }

        Callable releasePermit = () -> { semaphore.release();
            return null;
        };
        
        try {
            semaphore.acquire();
            ListenableFuture<Void> future1 = mapper.saveAsync(parameterisedListItem);
            ListenableFuture<Void> future2 = parameterisedListMsisdnMapper.saveAsync( mapParameterisedList(parameterisedListItem));
            Futures.whenAllSucceed(future1, future2).call(releasePermit, executor);

        } catch (InterruptedException e) {
            //FIXME handle exception in better way
            throw new RuntimeException("Semaphore was interrupted.");
        }
    }

public void saveAsync（ParameterizedListItem ParameterizedListItem）{
if（ParameterizedListItem.getId（）==null）{
参数化ListItem.setId（UUID.randomUUID（））；
}
设置冲突=validator.validate（ParameterizedListItem）；
if（inflictions！=null&！inflictions.isEmpty（））{
抛出新的ConstraintViolationException（违规）；
}
可调用的releasePermit=（）->{semaphore.release（）；
返回null；
};
试一试{
semaphore.acquire（）；
ListenableFuture1=mapper.saveAsync（ParameterizedListItem）；
ListenableFuture2=参数化ListMsisdnMapper.saveAsync（MapParameterizedList（ParameterizedListItem））；
期货。何时成功（未来1，未来2）。调用（释放许可证，执行人）；
}捕捉（中断异常e）{
//FIXME以更好的方式处理异常
抛出新的RuntimeException（“信号量被中断”）；
}
}

未来。完成时（未来，未来1）。运行（信号量：：释放，执行者）

应在成功或失败时组合并释放。是的，有效谢谢这回答了您的问题吗<代码>未来。完成时（未来，未来1）。运行（信号量：：释放，执行者）应在成功或失败时组合并释放。是的，有效谢谢这是否回答了您的问题？