Java 8并发性基本任务的最简单规范形式

我有两个问题： 1.在Java8中，作为任务运行

Callable

，捕获和处理结果的最简单规范形式是什么？ 2.在下面的示例中，在所有任务完成之前，保持主流程处于打开状态的最佳/最简单/最清晰的方法是什么

这是我到目前为止的一个例子——这是Java 8中最好的方法还是有更基本的方法

import java.util.*;
import java.util.concurrent.*;
import java.util.function.*;

public class SimpleTask implements Supplier<String> {
  private SplittableRandom rand = new SplittableRandom();
  final int id;
  SimpleTask(int id) { this.id = id; }
  @Override
  public String get() {
    try {
      TimeUnit.MILLISECONDS.sleep(rand.nextInt(50, 300));
    } catch(InterruptedException e) {
      System.err.println("Interrupted");
    }
    return "Completed " + id + " on " +
      Thread.currentThread().getName();
  }
  public static void main(String[] args) throws Exception {
    for(int i = 0; i < 10; i++)
      CompletableFuture.supplyAsync(new SimpleTask(i))
        .thenAccept(System.out::println);
    System.in.read(); // Or else program ends too soon
  }
}

import java.util.*；
导入java.util.concurrent.*；
导入java.util.function.*；
公共类SimpleTask实现了供应商{
private SplittableRandom rand=新的SplittableRandom（）；
最终int id；
SimpleTask（int-id）{this.id=id；}
@凌驾
公共字符串get（）{
试一试{
时间单位。毫秒。睡眠（兰特。耐克斯汀（50300））；
}捕捉（中断异常e）{
系统错误打印项次（“中断”）；
}
返回“已完成”+id+“打开”+
Thread.currentThread（）.getName（）；
}
公共静态void main（字符串[]args）引发异常{
对于（int i=0；i<10；i++）
CompletableFuture.SupplySync（新SimpleTask（i））
.thenAccept（System.out:：println）；
System.in.read（）；//否则程序结束得太快
}
}

---

有没有一种更简单更清晰的Java-8方法可以做到这一点？如何消除

系统中的.in.read（）

，以便采用更好的方法？

考虑将期货收集到列表中。然后，您可以在每个将来使用

join（）

，等待它们在当前线程中完成：

List<CompletableFuture<Void>> futures = IntStream.range(0,10)
        .mapToObj(id -> supplyAsync(new SimpleTask(id)).thenAccept(System.out::println))
        .collect(toList());

futures.forEach(CompletableFuture::join);

List futures=IntStream.range（0,10）
.mapToObj（id->supplyAsync（新的SimpleTask（id））.thenAccept（System.out:：println））
.collect（toList（））；
forEach（CompletableFuture:：join）；

等待多个

CompletableFuture

实例完成的标准方法是通过创建一个新实例，具体取决于所有实例。您可以使用这个新的未来来等待它的完成，或者像其他任何

CompletableFuture

一样安排新的后续行动：

CompletableFuture.allOf(
    IntStream.range(0,10).mapToObj(SimpleTask::new)
             .map(s -> CompletableFuture.supplyAsync(s).thenAccept(System.out::println))
             .toArray(CompletableFuture<?>[]::new)
).join();

Executors.newCachedThreadPool（）

返回的executor服务是非共享的，即使您忘记调用

shutDown（）

，也不会保持活动状态，但在终止所有线程之前可能需要一分钟的时间

因为您的第一个问题是：“在Java 8中，作为任务运行可调用函数、捕获和处理结果的最简单规范形式是什么？”，答案可能是最简单的形式仍然直接调用它的

call（）

方法，例如

Callable<String> c = () -> {
    LockSupport.parkNanos(TimeUnit.MILLISECONDS.toNanos(
            ThreadLocalRandom.current().nextInt(50, 300)));
    return "Completed on "+Thread.currentThread().getName();
};
String result = c.call();
System.out.println(result);

可调用c=（）->{
LockSupport.parknos（TimeUnit.millizes.toNanos(
ThreadLocalRandom.current（）.nextInt（50300））；
返回“Completed on”+Thread.currentThread（）.getName（）；
};
字符串结果=c.call（）；
系统输出打印项次（结果）；

没有比这更简单的方法了

Callable<String> c = () -> {
    LockSupport.parkNanos(TimeUnit.MILLISECONDS.toNanos(
            ThreadLocalRandom.current().nextInt(50, 300)));
    return "Completed on "+Thread.currentThread().getName();
};
String result = c.call();
System.out.println(result);