Java 如何使用CompletableFuture的SupplySync每次运行多个输入的相同方法？

我在下面的代码中创建了一个供应商，并使用completableFuture的SupplySync方法在异步执行后调用另一个方法

public void runParallelFunctions(MyInput myInput) {
    Supplier<Map<String, String>> taskSupplier = () -> {
        try {
            return invokeLambda("input1");
        } catch (Exception e) {
            System.out.println(e);
        }
        return new HashMap<>();
    };
    
    for (int i = 0; i < 5; i++) {
        CompletableFuture.supplyAsync(taskSupplier::get, executorService)
                         .thenAccept(this::printResultsFromParallelInvocations);
    }
    System.out.println("Doing other work....");
}

public void runparallel函数（MyInput MyInput）{
供应商任务供应商=（）->{
试一试{
返回invokeLambda（“input1”）；
}捕获（例外e）{
系统输出打印ln（e）；
}
返回新的HashMap（）；
};
对于（int i=0；i<5；i++）{
CompletableFuture.SupplySync（taskSupplier:：get，executorService）
.thenAccept（此：：printResultsFromParallelInvocations）；
}
System.out.println（“做其他工作…”）；
}

下面是我在执行完成后调用的方法

private void printResultsFromParallelInvocations(Map<String, String> result) {
        result.forEach((key, value) -> System.out.println(key + ": " + value));
}

private void printResultsFromParallelInvocations（映射结果）{
result.forEach（（key，value）->System.out.println（key+“：”+value））；
}

---

在上面的代码中，如何调用方法

invokeLambda

传递多个参数，如“input1”、“input2”等。？我可以通过一个循环生成输入，但是我如何与供应商一起使用某种列表，以便调用整个列表以获得SupplySync方法？我不能使用runAsync方法，因为我有一个返回值需要调用

printResultsFromParallelInvocations

。我对futures和async回调不熟悉，希望能得到任何帮助。提前感谢。

您可以在循环中动态创建新的供应商

public static Supplier<Map<String, String>> supplierFunc(Object... args) {
    return () -> {
        try {
            return invokeLambda(args);
        } catch (Exception e) {
            System.out.println(e);
        }
        return new HashMap<>();
    };
}

public void runParallelFunctions(Object myInput) {
    for (int i = 0; i < 5; i++) {
        CompletableFuture.supplyAsync(supplierFunc("input1", "input2"), executorService)
                .thenAccept(this::printResultsFromParallelInvocations);
    }
    System.out.println("Doing other work....");
}

publicstaticsuppliersupplierfunc（对象…参数）{
返回（）->{
试一试{
返回invokeLambda（args）；
}捕获（例外e）{
系统输出打印ln（e）；
}
返回新的HashMap（）；
};
}
公共函数（对象myInput）{
对于（int i=0；i<5；i++）{
CompletableFuture.supplyAsync（supplierFunc（“input1”、“input2”），executorService）
.thenAccept（此：：printResultsFromParallelInvocations）；
}
System.out.println（“做其他工作…”）；
}

您可以在循环内动态创建新供应商

public static Supplier<Map<String, String>> supplierFunc(Object... args) {
    return () -> {
        try {
            return invokeLambda(args);
        } catch (Exception e) {
            System.out.println(e);
        }
        return new HashMap<>();
    };
}

public void runParallelFunctions(Object myInput) {
    for (int i = 0; i < 5; i++) {
        CompletableFuture.supplyAsync(supplierFunc("input1", "input2"), executorService)
                .thenAccept(this::printResultsFromParallelInvocations);
    }
    System.out.println("Doing other work....");
}

publicstaticsuppliersupplierfunc（对象…参数）{
返回（）->{
试一试{
返回invokeLambda（args）；
}捕获（例外e）{
系统输出打印ln（e）；
}
返回新的HashMap（）；
};
}
公共函数（对象myInput）{
对于（int i=0；i<5；i++）{
CompletableFuture.supplyAsync（supplierFunc（“input1”、“input2”），executorService）
.thenAccept（此：：printResultsFromParallelInvocations）；
}
System.out.println（“做其他工作…”）；
}

您不能创建一个供应商，并期望它在五次评估中表现不同。这将需要外部可变状态，使其可检测到一个评估是第n个评估，这同时与执行五个没有顺序的并发评估的想法相矛盾

只需创建五个不同的供应商，例如

for（int i=0；i<5；i++）{
字符串输入=“输入”+i；
CompletableFuture.SupplySync（（）->invokeLambda（输入），executorService）
.thenAccept（此：：printResultsFromParallelInvocations）；
}

在每个循环迭代中，lambda表达式

（）->invokeLambda（输入）

捕获

输入的当前值

，并创建适当的

供应商

实例

旁注：

• 不要以技术方面命名方法，比如

  invokeLambda

  ，而是尝试表达它们的目的

• 原始代码中的

  taskSupplier:：get

  是一个不必要的方法引用，因为它生成了一个

  Supplier

  对已经是

  供应商的对象调用该方法。因此，如果每次评估都希望获得相同的行为，则可以将
  taskSupplier
  直接传递给
  supplyAsync
  
  

---

您不能创建一个供应商，并期望它在五次评估中表现不同。这将需要外部可变状态，使其可检测到一个评估是第n个评估，这同时与执行五个没有顺序的并发评估的想法相矛盾

只需创建五个不同的供应商，例如

for（int i=0；i<5；i++）{
字符串输入=“输入”+i；
CompletableFuture.SupplySync（（）->invokeLambda（输入），executorService）
.thenAccept（此：：printResultsFromParallelInvocations）；
}

在每个循环迭代中，lambda表达式

（）->invokeLambda（输入）

捕获

输入的当前值

，并创建适当的

供应商

实例

旁注：

• 不要以技术方面命名方法，比如

  invokeLambda

  ，而是尝试表达它们的目的

• 原始代码中的

  taskSupplier:：get

  是一个不必要的方法引用，因为它生成了一个

  Supplier

  对已经是

  供应商的对象调用该方法。因此，如果每次评估都希望获得相同的行为，则可以将
  taskSupplier
  直接传递给
  supplyAsync
  
  

---

无法理解这个问题。。供应商，以便我可以调用supplyAsync方法的整个列表：您能详细说明这一部分吗？为什么您坚持创建一个供应商来做不同的事情？顺便说一下，使用

taskSupplier:：get

而不仅仅是

taskSupplier

是没有意义的。使用前者，您将在每次迭代中创建一个新的供应商，它只调用现有供应商的

get

方法。对（inti=0；i<5；i++）{String input=“i”）使用类似于

的内容