JDK1.8新特性-CompletableFuture

JDK1.8新特性增加了一个CompletableFuture类为异步编程提供了极大地方便。下面通过几段代码对它进行试验。

代码1：

    public static void main(String args[]){
        CompletableFuture<String> completableFuture1 = CompletableFuture.supplyAsync(()->{
            try {
                for (int i = 0 ;i<=20;i++) {
                    Thread.sleep(1000);
                    System.out.println("future 1 painter "+i);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "future 1";
        });
        System.out.println("success step 1");
    ｝

输出

success step 1

原因：

主线程未做阻塞，作为守护线程，当主线程运行结束，子线程相应也就结束了。

 

代码2：

    public static void main(String args[]){
        CompletableFuture<String> completableFuture1 = CompletableFuture.supplyAsync(()->{
            try {
                for (int i = 0 ;i<=5;i++) {
                    Thread.sleep(1000);
                    System.out.println("future 1 painter "+i);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "future 1";
        });
        try {
            completableFuture1.get();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        System.out.println("success step 1");
    ｝

输出：

future 1 painter 0
future 1 painter 1
future 1 painter 2
future 1 painter 3
future 1 painter 4
future 1 painter 5
success step 1

分析：completableFuture1.get()会阻塞主线程，等到completableFuture1运行完才会继续往下运行，因此上面循环输出能够正常打印，success step 1在最后输出。

 

代码3：

    public static void main(String args[]){
        CompletableFuture<String> completableFuture1 = CompletableFuture.supplyAsync(()->{
            try {
                for (int i = 0 ;i<=20;i++) {
                    Thread.sleep(1000);
                    System.out.println("future 1 painter "+i);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "future 1";
        });

        System.out.println("success step 1");
        CompletableFuture<String> completableFuture2 = CompletableFuture.supplyAsync(()->{
            try {
                for (int i = 0 ;i<=10;i++) {
                    Thread.sleep(1000);
                    System.out.println("future 2 painter" +i);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "future 2";
        });
        System.out.println("success step 2");
        CompletableFuture fi = CompletableFuture.anyOf(completableFuture1,completableFuture2);
        try {
            System.out.println(fi.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    ｝

输出结果：

success step 1
success step 2
future 2 painter0
future 1 painter 0
future 1 painter 1
future 2 painter1
future 2 painter2
future 1 painter 2
future 2 painter3
future 1 painter 3
future 2 painter4
future 1 painter 4
future 1 painter 5
future 2 painter5
future 2 painter6
future 1 painter 6
future 2 painter7
future 1 painter 7
future 1 painter 8
future 2 painter8
future 2 painter9
future 1 painter 9
future 2 painter10
future 1 painter 10
future 2

结论：以上CompletableFuture的确异步执行了。后面CompletableFuture.anyOf做了断言合并，任何一个线程有结果返回，fi.get()作的阻断就会返回。其中anyOf()返回第一个执行完的结果的数据。

代码4：

public static void main(String args[]){
        CompletableFuture<String> completableFuture1 = CompletableFuture.supplyAsync(()->{
            try {
                for (int i = 0 ;i<=20;i++) {
                    Thread.sleep(1000);
                    System.out.println("future 1 painter "+i);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "future 1";
        });

        System.out.println("success step 1");
        CompletableFuture<String> completableFuture2 = CompletableFuture.supplyAsync(()->{
            try {
                for (int i = 0 ;i<=10;i++) {
                    Thread.sleep(1000);
                    System.out.println("future 2 painter" +i);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "future 2";
        });
        System.out.println("success step 2");
        CompletableFuture fi = CompletableFuture.allOf(completableFuture1,completableFuture2);
        try {
            System.out.println(fi.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }

输出：

success step 1
success step 2
future 2 painter0
future 1 painter 0
future 1 painter 1
future 2 painter1
future 1 painter 2
future 2 painter2
future 2 painter3
future 1 painter 3
future 2 painter4
future 1 painter 4
future 1 painter 5
future 2 painter5
future 1 painter 6
future 2 painter6
future 1 painter 7
future 2 painter7
future 1 painter 8
future 2 painter8
future 1 painter 9
future 2 painter9
future 1 painter 10
future 2 painter10
future 1 painter 11
future 1 painter 12
future 1 painter 13
future 1 painter 14
future 1 painter 15
future 1 painter 16
future 1 painter 17
future 1 painter 18
future 1 painter 19
future 1 painter 20
null

结果：allOf返回值null