Java 可计算的未来并行调用

我想并行运行10个API。每个API都返回一些值。当值的总计数等于100时，我想停止，也就是说，如果我在得到所有API的结果之前得到100个结果，我不想等待所有10个API。 所以我想在循环和返回中使用

CompletableFuture.anyOf（）

，但我无法找到正确的语法。还有，是否有其他有效的方法

请回复

---

提前谢谢

您可以使用倒计时闩锁

    ExecutorService executor = Executors.newFixedThreadPool(10);

    List<Integer> results = new ArrayList<>();
    int maxResults = 100;
    CountDownLatch latch = new CountDownLatch(maxResults);

    for (int i = 0; i < 10; ++i) {
        int apiNumber = i;
        executor.execute(() -> {
            while (results.size() < maxResults) {
                try {
                    Thread.sleep(new Random().nextInt(1000));
                    System.out.println("API-" + apiNumber + " call");
                    int[] newValues = new Random().ints(0, 10).limit(new Random().nextInt(10)).toArray(); // API call
                    for (int value : newValues) {
                        synchronized (results) {
                            if (results.size() < maxResults) {
                                results.add(value);
                                latch.countDown();
                            }
                        }
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
    }

    latch.await();

    System.out.println("The results have been calculated (" + results.size() + ")");


    executor.shutdown();

ExecutorService executor=Executors.newFixedThreadPool（10）；
列表结果=新建ArrayList（）；
int maxResults=100；
CountDownLatch闩锁=新的CountDownLatch（maxResults）；
对于（int i=0；i<10；++i）{
整数=i；
执行者。执行（（）->{
while（results.size（）

移相器

    ExecutorService executor = Executors.newFixedThreadPool(10);

    List<Integer> results = new ArrayList<>();
    int maxResults = 100;
    Phaser phaser = new Phaser(1);
    phaser.register();

    for (int i = 0; i < 10; ++i) {
        int apiNumber = i;
        executor.execute(() -> {
            while (results.size() < maxResults) {
                try {
                    Thread.sleep(new Random().nextInt(1000));
                    System.out.println("API-" + apiNumber + " call");
                    int[] newValues = new Random().ints(0, 10).limit(new Random().nextInt(10)).toArray(); // API call
                    for (int value : newValues) {
                        synchronized (results) {
                            results.add(value);
                            if (results.size() >= maxResults) {
                                phaser.arrive();
                                break;
                            }
                        }
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
    }

    phaser.arriveAndAwaitAdvance();

    System.out.println("The results have been calculated (" + results.size() + ")");

    executor.shutdown();

ExecutorService executor=Executors.newFixedThreadPool（10）；
列表结果=新建ArrayList（）；
int maxResults=100；
移相器移相器=新移相器（1）；
相量寄存器（）；
对于（int i=0；i<10；++i）{
整数=i；
执行者。执行（（）->{
while（results.size（）=maxResults）{
相位器到达（）；
打破
}
}
}
}捕捉（中断异常e）{
e、 printStackTrace（）；
}
}
});
}
相位器。到达并等待前进（）；
System.out.println（“已计算结果（“+results.size（）+”））；
executor.shutdown（）；

您可以使用CountDownLatch

    ExecutorService executor = Executors.newFixedThreadPool(10);

    List<Integer> results = new ArrayList<>();
    int maxResults = 100;
    CountDownLatch latch = new CountDownLatch(maxResults);

    for (int i = 0; i < 10; ++i) {
        int apiNumber = i;
        executor.execute(() -> {
            while (results.size() < maxResults) {
                try {
                    Thread.sleep(new Random().nextInt(1000));
                    System.out.println("API-" + apiNumber + " call");
                    int[] newValues = new Random().ints(0, 10).limit(new Random().nextInt(10)).toArray(); // API call
                    for (int value : newValues) {
                        synchronized (results) {
                            if (results.size() < maxResults) {
                                results.add(value);
                                latch.countDown();
                            }
                        }
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
    }

    latch.await();

    System.out.println("The results have been calculated (" + results.size() + ")");


    executor.shutdown();

ExecutorService executor=Executors.newFixedThreadPool（10）；
列表结果=新建ArrayList（）；
int maxResults=100；
CountDownLatch闩锁=新的CountDownLatch（maxResults）；
对于（int i=0；i<10；++i）{
整数=i；
执行者。执行（（）->{
while（results.size（）

移相器

    ExecutorService executor = Executors.newFixedThreadPool(10);

    List<Integer> results = new ArrayList<>();
    int maxResults = 100;
    Phaser phaser = new Phaser(1);
    phaser.register();

    for (int i = 0; i < 10; ++i) {
        int apiNumber = i;
        executor.execute(() -> {
            while (results.size() < maxResults) {
                try {
                    Thread.sleep(new Random().nextInt(1000));
                    System.out.println("API-" + apiNumber + " call");
                    int[] newValues = new Random().ints(0, 10).limit(new Random().nextInt(10)).toArray(); // API call
                    for (int value : newValues) {
                        synchronized (results) {
                            results.add(value);
                            if (results.size() >= maxResults) {
                                phaser.arrive();
                                break;
                            }
                        }
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
    }

    phaser.arriveAndAwaitAdvance();

    System.out.println("The results have been calculated (" + results.size() + ")");

    executor.shutdown();

ExecutorService executor=Executors.newFixedThreadPool（10）；
列表结果=新建ArrayList（）；
int maxResults=100；
移相器移相器=新移相器（1）；
相量寄存器（）；
对于（int i=0；i<10；++i）{
整数=i；
执行者。执行（（）->{
while（results.size（）=maxResults）{
相位器到达（）；
打破
}
}
}
}捕捉（中断异常e）{
e、 printStackTrace（）；
}
}
});
}
相位器。到达并等待前进（）；
System.out.println（“已计算结果（“+results.size（）+”））；
executor.shutdown（）；

谢谢您的回答，但这似乎是一个低效的解决方案。我们正在调用

latch.countDown（）用于每个结果。假设我们在第一次API调用中得到的结果大小是12K。得到结果后，
lack.countDown（）
将被调用12K次。您也可以使用PhaserPlease打开问题。这也是低效的。