Java 关于使用CompletableFuture的建议

我想要一些关于未来使用CompletableFuture的好方法的建议

如果我有一个整数列表，对于每个整数，我想执行3个操作，这需要一些时间。例如，乘法、除法和减法

对于结果，它应该是map，其中key是整数，value是包含三个操作结果的list

场景1：如果我想在完成一个整数的处理后将结果写入映射，那么下面是一个好方法吗

for (int x : nums) {
  CompletableFuture<Integer> multiply = CompletableFuture.supplyAsync(() -> multiply(x));
  CompletableFuture<Integer> divide = CompletableFuture.supplyAsync(() -> divide(x));
  CompletableFuture<Integer> subtract = CompletableFuture.supplyAsync(() -> subtract(x));

  CompletableFuture<Void> allRequests = CompletableFuture.allOf(multiple, divide, substract);

  //iterate the three CompletableFuture and add to the map.
}

for（int x:nums）{
CompletableFuture multiply=CompletableFuture.supplyAsync（（）->multiply（x））；
CompletableFuture divide=CompletableFuture.supplyAsync（（）->divide（x））；
CompletableFuture subtract=CompletableFuture.supplyAsync（（）->subtract（x））；
CompletableFuture allRequests=CompletableFuture.allOf（倍数、除法、减法）；
//迭代三个CompletableFuture并添加到地图中。
}

场景2：如果我想将结果写入映射，直到所有过程完成

List<CompletableFuture<Void>> allRequests = new ArrayList<>();

for (int x : nums) {
  CompletableFuture<Integer> multiply = CompletableFuture.supplyAsync(() -> multiply(x));
  CompletableFuture<Integer> divide = CompletableFuture.supplyAsync(() -> divide(x));
  CompletableFuture<Integer> subtract = CompletableFuture.supplyAsync(() -> subtract(x));

  CompletableFuture<Void> allRequestsPerNum = CompletableFuture.allOf(multiple, divide, substract);

  allRequests.add(allRequestsPerNum);
}

CompletableFuture.allOf(allRequest);

//How am I suppose to build the result?

List allRequests=new ArrayList（）；
用于（整数x:nums）{
CompletableFuture multiply=CompletableFuture.supplyAsync（（）->multiply（x））；
CompletableFuture divide=CompletableFuture.supplyAsync（（）->divide（x））；
CompletableFuture subtract=CompletableFuture.supplyAsync（（）->subtract（x））；
CompletableFuture allRequestsPerNum=CompletableFuture.allOf（倍数、除法、减法）；
添加（allRequestsPerNum）；
}
CompletableFuture.allOf（allRequest）；
//我该如何建立结果？

---

对于场景2，如果我们在For循环中调用

CompletableFuture.allOf

，这意味着在我们移动到下一个数字之前需要完成三个操作？

您可以使用

CompletableFuture

中内置的功能，这些功能未经测试，因此可能存在一些小问题。这会给你一个好主意

    List<CompletableFuture<Void>> allRequests = new ArrayList<>();

    for (int x : nums) {
         allRequests.add(CompletableFuture.allOf(
                CompletableFuture.supplyAsync(() -> multiply(x)).thenApplyAsync(() -> addToMap()),
                CompletableFuture.supplyAsync(() -> divide(x)).thenApplyAsync(() -> addToMap()),
                CompletableFuture.supplyAsync(() -> subtract(x)).thenApplyAsync(() -> addToMap())));
    }
    CompletableFuture.allOf(allRequests.toArray(new CompletableFuture[])).join();

List allRequests=new ArrayList（）；
用于（整数x:nums）{
allRequests.add（CompletableFuture.allOf(
CompletableFuture.supplyAsync（（）->乘法（x））。然后应用同步（（）->addToMap（）），
CompletableFuture.supplyAsync（（）->divide（x））。然后应用同步（（）->addToMap（）），
CompletableFuture.supplyAsync（（）->subtract（x））。然后应用同步（（）->addToMap（））；
}
CompletableFuture.allOf（allRequests.toArray（新的CompletableFuture[]）.join（）；

类似于以下内容的内容应该适合您：

正如在评论中提到的，我没有承诺这样做会带来任何性能方面的好处。我也没有承诺这是做这件事的“最佳实践”

// Keep all the futures around
final Collection<CompletableFuture<?>> futures = new ArrayList<>();

// And prepare the resulting map
final Map<Integer, List<Integer>> map = new HashMap<>();

for (int x : Arrays.asList(1, 2, 3)) {
    // Create the map value List.
    // Initialise it with some default values so that 'set'
    // works.  Use a concurrent-safe List so that there's
    // no risk of corruption from the async operations.
    final List<Integer> value = new CopyOnWriteArrayList<>(Arrays.asList(0, 0, 0));

    // Put the key and List (not yet ready) into the Map
    map.put(x, value);

    // Add all of your futures to your tracking Collection.
    // Note: each future now includes setting the appropriate
    // entry in the List to that result.
    futures.add(CompletableFuture.supplyAsync(() -> 2 * x)
            .thenAcceptAsync(result -> value.set(0, result)));
    futures.add(CompletableFuture.supplyAsync(() -> 2 / x)
            .thenAcceptAsync(result -> value.set(1, result)));
    futures.add(CompletableFuture.supplyAsync(() -> 2 - x)
            .thenAcceptAsync(result -> value.set(2, result)));
}

// Wait for them all to complete.
CompletableFuture.allOf(futures.toArray(new CompletableFuture[0])).join();

//保持所有的未来
最终收藏这是使用
CompletableFuture
的教程练习吗？因为在你加上相当大的开销后，几个甚至有些复杂的算术计算在主线程中完成的速度要比并行计算快。我知道这会增加开销。但是，我们希望使用
CompletableFuture
并在负载测试中评估此机制。您是否关心
列表中元素的顺序，或者只是要求它“包含”它们（如问题中所述）？@BeUndead因为结果将是map，只要我能找到输入的结果，顺序不重要。它是一个
映射
，但您说过该
映射
中条目的值是该
int
操作结果的
列表
。例如，条目
{1:[1，2，3]
中
[1，2，3]}
的顺序对您重要吗？