如何使用Semaphore和CompletableFuture搭配实现控制线程并发数量并等待所有线程执行完成之后在执行其它操作

代码示例：

 public static void main(String[] args) throws InterruptedException {
        ExecutorService executor = Executors.newFixedThreadPool(4);
        Semaphore semaphore = new Semaphore(2);

        try {
            CompletableFuture<String> futureA = CompletableFuture.supplyAsync(() -> {
                try {
                    semaphore.acquire(); // 获取信号量，限制并发数
                    // 调用外部接口 A
                    System.out.println("A进入车库");
                    Thread.sleep(9000);
                    System.out.println("A离开车位");
                    return "A";
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                } finally {
                    semaphore.release(); // 释放信号量
                }
            }, executor);

            CompletableFuture<String> futureB = CompletableFuture.supplyAsync(() -> {
                try {
                    semaphore.acquire(); // 获取信号量，限制并发数
                    // 调用外部接口 B
                    System.out.println("B进入车库");
                    Thread.sleep(9000);
                    System.out.println("B离开车位");
                    return "B";
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                } finally {
                    semaphore.release(); // 释放信号量
                }
            }, executor);

            CompletableFuture<String> futureC = CompletableFuture.supplyAsync(() -> {
                try {
                    semaphore.acquire(); // 获取信号量，限制并发数
                    // 调用外部接口 C
                    System.out.println("C进入车库");
                    Thread.sleep(9000);
                    System.out.println("C离开车位");
                    return "C";
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                } finally {
                    semaphore.release(); // 释放信号量
                }
            }, executor);

            CompletableFuture<String> futureD = CompletableFuture.supplyAsync(() -> {
                try {
                    semaphore.acquire(); // 获取信号量，限制并发数
                    // 调用外部接口 D
                    System.out.println("D进入车库");
                    Thread.sleep(9000);
                    System.out.println("D离开车位");
                    return "D";
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                } finally {
                    semaphore.release(); // 释放信号量
                }
            }, executor);

            CompletableFuture<Void> combinedFuture = CompletableFuture.allOf(futureA, futureB, futureC, futureD);
            combinedFuture.thenAccept(result -> {
                // 汇总数据
                String dataA = futureA.join();
                String dataB = futureB.join();
                String dataC = futureC.join();
                String dataD = futureD.join();
                String combinedData = dataA + dataB + dataC + dataD;
                System.out.println(combinedData);
            });
        } catch (Exception exception) {
            exception.printStackTrace();
        }

        executor.shutdown();
    }

打印结果：