Java'；s完全的未来和线程

我想用

CompletableFuture

Java8-9启动线程，使用异步模式，这些是我的类和线程：

我有三条线。我的类包含一个方法

myMethod（）

设置我的

Runnable

s，如下所示：

Runnable runnableClass_1 = new Runnable(){
    public void run(){
        class_1.myMethod();
        try { Thread.sleep(0); } catch (InterruptedException e) { e.printStackTrace(); }
    }
};

Runnable runnableClass_2 = new Runnable(){
    public void run(){
        class_2.myMethod();
        try { Thread.sleep(0); } catch (InterruptedException e) { e.printStackTrace(); }
    }
};

Runnable runnableClass_3 = new Runnable(){
    public void run(){
        class_3.myMethod();
        try { Thread.sleep(0); } catch (InterruptedException e) { e.printStackTrace(); }
    }
};  

创建线程：

Thread t_1 = new Thread( runnableClass_1 );

Thread t_2 = new Thread( runnableClass_2 );

Thread t_3 = new Thread( runnableClass_3 );

---

最后，我的问题是如何使用

CompletableFuture

异步模式启动这三个线程。

以下是如何实现相同的线程：

List<String> results = new ArrayList<String>();

        CompletableFuture<Void> run1 = CompletableFuture.runAsync(() -> {
                pauseSeconds(2);
                results.add("first task");
            }, service);

        CompletableFuture<Void> run2 = CompletableFuture.runAsync(() -> {
                pauseSeconds(3);
                results.add("second task");
            }, service);

        CompletableFuture<Void> finisher = run1.runAfterBothAsync(run2,
                                            () -> results.add(results.get(0)+ "&"+results.get(1)),service);
         pauseSeconds(4);
         System.out.println("finisher.isDone() = "+finisher.isDone());
         System.out.println("results.get(2) = "+results.get(2));
//       assert(finisher.isDone(), is(true));
//       assertThat(results.get(2),is("first task&second task"));
        }

public static void pauseSeconds(int num){
        try {
            Thread.sleep(num);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

List results=new ArrayList（）；
CompletableFuture run1=CompletableFuture.runAsync（（）->{
暂停秒（2）；
结果。添加（“第一项任务”）；
}(服务),；
CompletableFuture run2=CompletableFuture.runAsync（（）->{
暂停秒（3）；
结果。添加（“第二项任务”）；
}(服务),；
CompletableFuture finisher=run1.runAfterBothAsync（run2，
（）->results.add（results.get（0）+“&”+results.get（1）），服务）；
暂停秒（4）；
System.out.println（“finisher.isDone（）=”+finisher.isDone（））；
System.out.println（“results.get（2）=”+results.get（2））；
//断言（finisher.isDone（），is（true））；
//资产（results.get（2）是（“第一个任务和第二个任务”）；
}
公共静态无效暂停秒（int num）{
试一试{
睡眠（num）；
}捕捉（中断异常e）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
}

如何设置（以及可能组合）未来取决于您的用例：这些未来相互依赖吗？您需要按顺序执行它们还是可以并行运行它们？你是关心这三个结果，还是只需要哪一个未来先完成

根据您的答案，您可以使用

flatMap/bind

组合器（它们对

CompletableFuture

有不同的名称，但您可以计算出来）按顺序链接您的未来，或者您可以从当前线程中生成所有未来（让它们并行运行），然后等待它们全部完成。您还可以指定特定的线程池，以

CompletableFuture

just-use默认（ForkJoinPool）的工厂方法

所有这些都可以通过提供的

Future

的一元版本非常简洁地完成。但是，如果您查看一下它的功能，您还可以使用

CompletableFuture

提出一个解决方案

更新/请求示例：

下面的示例基本上取自，其中提供的期货并行运行，所有期货的结果都累积到一个集合中。您要做的是，将

列表

转换为

未来

---

如果您不需要自己控制线程处理，您可以简单地使用。如果需要更多控制，请使用带有

Executor

参数的版本，并自定义

Executor

。最后，如果你真的需要使用这3个特定的线程，你必须在

可运行的
中管理
CompletableFuture
自己。我感兴趣的是尽可能节省时间，在我使用
CompletableFuture
之前，我的内存非常有限，所以我使用了
顺序模式，现在我预告了我的备忘录，然后是处理器，我对在
并行
中使用
completedlefuture
感兴趣，你能举个例子吗。我接受你的回答，原因是，我被允许进行一些修改，但你的主要方法得到了很好的保留，；）@YohanT Sry让你很困惑。当我谈论接受我的答案时，我指的是StackOverflow上的“接受答案”功能。您可以在此处阅读：
List<String> results = new ArrayList<String>();

        CompletableFuture<Void> run1 = CompletableFuture.runAsync(() -> {
                pauseSeconds(2);
                results.add("first task");
            }, service);

        CompletableFuture<Void> run2 = CompletableFuture.runAsync(() -> {
                pauseSeconds(3);
                results.add("second task");
            }, service);

        CompletableFuture<Void> finisher = run1.runAfterBothAsync(run2,
                                            () -> results.add(results.get(0)+ "&"+results.get(1)),service);
         pauseSeconds(4);
         System.out.println("finisher.isDone() = "+finisher.isDone());
         System.out.println("results.get(2) = "+results.get(2));
//       assert(finisher.isDone(), is(true));
//       assertThat(results.get(2),is("first task&second task"));
        }

public static void pauseSeconds(int num){
        try {
            Thread.sleep(num);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    final long startTime = System.currentTimeMillis();
    final CompletableFuture<String> foo = CompletableFuture.supplyAsync(() -> {
        final long timeout = 500;
        try {
            Thread.sleep(timeout);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(String.format("foo on %s sleeping for %s", Thread.currentThread(), timeout));
        return "foo";
    });
    final CompletableFuture<String> bar = CompletableFuture.supplyAsync(() -> {
        final long timeout = 100;
        try {
            Thread.sleep(timeout);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(String.format("bar on %s sleeping for %s", Thread.currentThread(), timeout));
        return "bar";
    });
    final CompletableFuture<String> baz = CompletableFuture.supplyAsync(() -> {
        final long timeout = 1000;
        try {
            Thread.sleep(timeout);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(String.format("baz on %s sleeping for %s", Thread.currentThread(), timeout));
        return "baz";
    });

    CompletableFuture
            .supplyAsync(() -> Stream.of(foo, bar, baz).map(future -> future.join()).collect(Collectors.toList()))
            .thenAccept(done -> System.out.println(String.format("Done with all futures %s", done)))
            .thenRun(() -> System.out.println(String.format("Running all futures in parallel took %s millis", System.currentTimeMillis() - startTime)));

bar on Thread[ForkJoinPool.commonPool-worker-2,5,main] sleeping for 100
foo on Thread[ForkJoinPool.commonPool-worker-9,5,main] sleeping for 500
baz on Thread[ForkJoinPool.commonPool-worker-11,5,main] sleeping for 1000
Done with all futures [foo, bar, baz]
Running all futures in parallel took 1007 millis