Java8学习计划--关于多核多线程并发编程-Java8-CompletableFuture 4的介绍

零零散散接近一个月的课余时间，学完Java8InAction和Guava，感触很多，收获也很大，特别开心，接下来会利用空余时间学习Spark，希望自己在技术上慢慢积累，越来越从容。

对于Java8 最大的改变是lambda表达式 Collecotors CompletableFutures等 Funtional Programing.的思想真的很强大

下面介绍Java8 CompletableFuture 4

* com.company.LambdaExpressions.Futures.CompletableFuture
* 对CompletableFuture主要的API的使用
* 针对多个线程之间的通信/线程等待/所有任务执行完成/部分线程任务执行完成  执行接下来的操作非常强大
* 1.runAfterBoth 两个线程都执行完后进行接下来的操作
* 2.acceptEither 两个任务 谁先执行完 谁执行接下来的action或者consumer等
* 3.applyToEither 两个任务 谁先执行完 谁执行Function 然后输出等action
* 4.runAfterEither  两个任务 谁先执行完 谁执行接下来的action
* 5.anyOf 任意一个任务执行完 do next action
* 6.allOf 任意一个任务执行完 do next action

package com.company.LambdaExpressions.Futures.CompletableFuture;

import java.util.Arrays;
import java.util.List;
import java.util.Random;
import java.util.concurrent.CompletableFuture;

import static java.util.stream.Collectors.toList;

/**
 * Created by mengxiaopeng on 2018/3/9.
 * com.company.LambdaExpressions.Futures.CompletableFuture
 * 对CompletableFuture主要的API的使用
 * 针对多个线程之间的通信/线程等待/所有任务执行完成/部分线程任务执行完成  执行接下来的操作非常强大
 * 1.runAfterBoth 两个线程都执行完后进行接下来的操作
 * 2.acceptEither 两个任务 谁先执行完 谁执行接下来的action或者consumer等
 * 3.applyToEither 两个任务 谁先执行完 谁执行Function 然后输出等action
 * 4.runAfterEither  两个任务 谁先执行完 谁执行接下来的action
 * 5.anyOf 任意一个任务执行完 do next action
 * 6.allOf 任意一个任务执行完 do next action
 *
 */
public class MyCompletableFutureInAction4 {
    private static Random random = new Random();

    public static void main(String[] args) {
        //##runAfterBoth 当两个线程都执行完毕后 进行一个Runnable的action
        //默认采用ForkJoin的pool来操作
        CompletableFuture.supplyAsync(
                () -> {
                    System.out.println(Thread.currentThread().getName() + " is running..");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    return 1;
                }
        ).runAfterBoth(CompletableFuture.supplyAsync(
                () -> {
                    System.out.println(Thread.currentThread().getName() + " is running..");
                    return 2;
                }
        ), () -> System.out.println("Task1 and Task2 done"));


        //acceptEither 两个任务 谁先执行完 谁执行Runnable的action
        CompletableFuture.supplyAsync(() -> {
            System.out.println("Iam future1");
            return MyCompletableFutureInAction4.generateRandomDouble();
        })
                .acceptEither(CompletableFuture.supplyAsync(
                        () -> {
                            System.out.println("Iam future2");
                            return MyCompletableFutureInAction4.generateRandomDouble();
                        }

                ), System.out::println);

        //applyToEither 两个任务 谁先执行完 谁执行Function 然后输出等action
        CompletableFuture.supplyAsync(() -> {
            System.out.println("Iam future1");
            return MyCompletableFutureInAction4.generateRandomDouble();
        })
                .applyToEither(CompletableFuture.supplyAsync(
                        () -> {
                            System.out.println("Iam future2");
                            return MyCompletableFutureInAction4.generateRandomDouble();
                        }

                ), v -> v * 100).thenAccept(System.out::println);


        //## runAfterEither  两个任务 谁先执行完 谁执行Runnable的action
        CompletableFuture.supplyAsync(() -> {
            System.out.println("[runAfterEither] I am future1");
            return MyCompletableFutureInAction4.generateRandomDouble();
        }).runAfterEither(CompletableFuture.supplyAsync(
                        () -> {
                            System.out.println("[runAfterEither] Iam future2");
                            return MyCompletableFutureInAction4.generateRandomDouble();
                        }

                ), System.out::println);

        //##  anyOf 任意一个执行完 可以进行接下来的操作
        List> futures = Arrays.asList(1, 2, 3, 4)
                .stream()
                .map(i -> CompletableFuture.supplyAsync(MyCompletableFutureInAction4::generateRandomDoubleAnyOfAllOf))
                .collect(toList());

        CompletableFuture[] arrayFutures = futures.toArray(new CompletableFuture[futures.size()]);
        //anyOf(CompletableFuture... cfs) cfs是数组
       /* CompletableFuture.anyOf(arrayFutures)
                .thenRun(()->{
                    System.out.println("[any Of Tasks]  done..");
                });*/


        //##  allOf 所有的执行完
        //anyOf(CompletableFuture... cfs) cfs是数组
        CompletableFuture.allOf(arrayFutures)
                .thenRun(()->{
                    System.out.println("[***all*** Of Tasks]  done..");
                });


        //让当前线程挂起
        try {
            Thread.currentThread().join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }


    public static Double generateRandomDouble() {
        try {
            Thread.sleep(1000);
            double value = random.nextDouble();
            return value;
        } catch (InterruptedException e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }


    public static Double generateRandomDoubleAnyOfAllOf() {
        try {
            System.out.println("AnyOf or AllOf excutorStart");
            Thread.sleep(random.nextInt(20)*1000);
            double value = random.nextDouble();
            System.out.println("AnyOf or AllOf excutorEnd");
            return value;
        } catch (InterruptedException e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }
}