java多线程CompletableFuture

java8比较实用的一个多线程api

• 开启一个异步任务supplyAsync

    public static void main(String[] args) {
        ExecutorService executor = Executors.newCachedThreadPool();
        Supplier<List<String>> task1 = () -> {
            info("task1 begin");
            sleep(2000);
            return new ArrayList() {{add("1");}};
        };
        //supplyAsync方法入参(Supplier,Executor)
        //第一个参数是需要执行的任务，返回的类型和task的泛型一致
        //第二个参数是执行任务的线程池，这是个重载的方法，不传则使用默认线程池
        CompletableFuture<List<String>> completableFuture = CompletableFuture.supplyAsync(task1,executor);
        info(completableFuture.join());//join阻塞式获取结果，与get方法样
        info("主线程结束");
        executor.shutdown();
    }

    private static void sleep(int i) {
        //模拟任务执行时间
        try {
            Thread.sleep(i);
        } catch (InterruptedException e) {
        }
    }

    private static void info(List<String> info) {
        System.out.println(Thread.currentThread().getName() + "------" + info);
    }

    private static void info(String info) {
        System.out.println(Thread.currentThread().getName() + "------" + info);
    }

 类似方法：runAsync开启没有返回值的任务

• 合并两个任务thenCombine

    public static void main(String[] args) {
        ExecutorService executor = new ThreadPoolExecutor(0, Integer.MAX_VALUE, 0, TimeUnit.SECONDS, new SynchronousQueue<Runnable>());
        Supplier<List<String>> task1 = () -> {
            info("task1 begin");
            sleep(1000);
            return new ArrayList() {{ add("1"); }};
        };
        Supplier<List<String>> task2 = () -> {
            info("task2 begin");
            sleep(2000);
            return new ArrayList() {{ add("2"); }};
        };
        Supplier<List<String>> task3 = () -> {
            info("task3 begin");
            sleep(3000);
            return new ArrayList() {{ add("3"); }};
        };
        BiFunction<List<String>,List<String>,List<String>> combineFunc = (task1Result,task2Result)->{
            info("combine begin");
            task1Result.addAll(task2Result);
            return task1Result;
        };
        //thenCombine(CompletableFuture,BiFunction)合并另一个任务，第二个参数处理2个任务的结果，这个处理结果BiFunction由这2个任务中结束慢的线程执行（例中1，2任务一起跑，由2任务的线程执行合并结果的BiFunction）
        //thenCombineAsync(CompletableFuture,BiFunction,Executor)重载方法，合并结果的BiFunction由线程池中的线程异步执行，不传第三个线程池则使用默认线程池执行合并结果
        CompletableFuture<List<String>> completableFuture = CompletableFuture.supplyAsync(task1,executor)
                .thenCombine(CompletableFuture.supplyAsync(task2,executor),combineFunc)
                .thenCombine(CompletableFuture.supplyAsync(task3,executor),combineFunc);
        info(completableFuture.join());
        info("主线程结束");
        executor.shutdown();
    }

  类似方法：thenAcceptBoth接收两个任务的结果但没有返回值，thenAfterBoth不关心两个任务的结果且没有返回值

• 顺序执行的任务

1.thenApply

    public static void main(String[] args) {
        ExecutorService executor = new ThreadPoolExecutor(0, Integer.MAX_VALUE, 0, TimeUnit.SECONDS, new SynchronousQueue<Runnable>());
        Supplier<List<String>> task1 = () -> {
            info("task1 begin");
            sleep(1000);
            return new ArrayList() {{ add("1"); }};
        };
        Function<List<String>,List<String>> applyFunc = (task1Result->{
            info("task2 begin");
            sleep(2000);
            task1Result.add("2");
            return task1Result;
        });
        //thenApplyAsync 和 thenApply区别是，去掉async则把task2和task1合并在一个线程中执行
        CompletableFuture<List<String>> completableFuture = CompletableFuture.supplyAsync(task1,executor).thenApplyAsync(applyFunc,executor);
        info(completableFuture.join());
        info("主线程结束");
        executor.shutdown();
    }

类似方法：thenRun不接收task1结果且没有返回值，thenAccept接收task1结果且没有返回值

2.thenCompose

　　　public static void main(String[] args) {
        ExecutorService executor = new ThreadPoolExecutor(0, Integer.MAX_VALUE, 0, TimeUnit.SECONDS, new SynchronousQueue<Runnable>());
        Supplier<List<String>> task1 = () -> {
            info("task1 begin");
            sleep(1000);
            return new ArrayList() {{ add("1"); }};
        };
        Function<List<String>,CompletableFuture<List<String>>> composeFunc = (task1Result->{
            info("compose task begin");
            sleep(2000);
            task1Result.add("com");
            return CompletableFuture.supplyAsync(() -> {
                info("task2 begin");
                sleep(2000);
                task1Result.add("2");
                return task1Result;
            },executor);
        });
        //composeFunc中有2段代码块，需要执行，一段是compose task;二段是task2;
        //task1执行完成后，执行compose task，最后执行task2，顺序执行（每段执行完后执行下一段）
        //thenComposeAsync和thenCompose的区别是：compose task的执行线程，thenCompose使用task1的线程执行，thenComposeAsync则使用第二个参数中线程池（不传入executor则使用默认线程池）执行
        CompletableFuture<List<String>> completableFuture = CompletableFuture.supplyAsync(task1,executor).thenComposeAsync(composeFunc,executor);
        info(completableFuture.join());
        info("主线程结束");
        executor.shutdown();
    }

• 对两个任务中最先执行完成的结果进行处理applyToEither

    public static void main(String[] args) {
        ExecutorService executor = new ThreadPoolExecutor(0, Integer.MAX_VALUE, 0, TimeUnit.SECONDS, new SynchronousQueue<Runnable>());
        Supplier<List<String>> task1 = () -> {
            info("task1 begin");
            sleep(1000);
            return new ArrayList() {{ add("1"); }};
        };
        Supplier<List<String>> task2 = () -> {
            info("task2 begin");
            sleep(2000);
            return new ArrayList() {{ add("2"); }};
        };
        Function<List<String>,List<String>> eitherFunc = (fasterTask->{
            info("fasterTask");
            fasterTask.add("f");
            return fasterTask;
        });
        //applyToEither接收一个任务CompletableFuture和一个处理结果的Function，两个任务优先执行完的任务将结果传入Function处理
        //applyToEither 和 applyToEitherAsync区别是，applyToEither再较快task执行完成后继续用该线程执行eitherFunc，Async将eitherFunc放入新的线程执行
        CompletableFuture<List<String>> completableFuture = CompletableFuture.supplyAsync(task1,executor).applyToEitherAsync(CompletableFuture.supplyAsync(task2,executor),eitherFunc,executor);
        info(completableFuture.join());
        info("主线程结束");
        executor.shutdown();
    }

类似方法：acceptEither接收最快任务的结果但没有返回值，runAfterEither不关心最快任务的结果也没有返回值

• 同时执行多个任务

1.allOf

    public static void main(String[] args) {
        ExecutorService executor = new ThreadPoolExecutor(0, Integer.MAX_VALUE, 0, TimeUnit.SECONDS, new SynchronousQueue<Runnable>());
        Supplier<List<String>> task1 = () -> {
            info("task1 begin");
            sleep(1000);
            return new ArrayList() {{ add("1"); }};
        };
        Supplier<List<String>> task2 = () -> {
            info("task2 begin");
            sleep(2000);
            return new ArrayList() {{ add("2"); }};
        };
        Supplier<List<String>> task3 = () -> {
            info("task3 begin");
            sleep(5000);
            return new ArrayList() {{ add("3"); }};
        };
        //同时执行task123，没有返回值
        CompletableFuture<Void> completableFuture =
                CompletableFuture.allOf(
                          CompletableFuture.supplyAsync(task1,executor)
                        ,CompletableFuture.supplyAsync(task2,executor)
                        ,CompletableFuture.supplyAsync(task3,executor));
        info("主线程继续");
        //join方法在这里阻塞至所有任务执行完成
        completableFuture.join();
        info("主线程结束");
        executor.shutdown();
    }

2.anyOf

    public static void main(String[] args) {
        ExecutorService executor = new ThreadPoolExecutor(0, Integer.MAX_VALUE, 0, TimeUnit.SECONDS, new SynchronousQueue<Runnable>());
        Supplier<List<String>> task1 = () -> {
            info("task1 begin");
            sleep(1000);
            return new ArrayList() {{ add("1"); }};
        };
        Supplier<List<String>> task2 = () -> {
            info("task2 begin");
            sleep(2000);
            return new ArrayList() {{ add("2"); }};
        };
        Supplier<List<String>> task3 = () -> {
            info("task3 begin");
            sleep(5000);
            return new ArrayList() {{ add("3"); }};
        };
        //同时执行task123，返回最先执行完成任务的结果
        //由于多个任务返回值可以不一致，用object接收
        CompletableFuture<Object> completableFuture = CompletableFuture.anyOf(
                CompletableFuture.supplyAsync(task1, executor)
                , CompletableFuture.supplyAsync(task2, executor)
                , CompletableFuture.supplyAsync(task3, executor));
        info("主线程继续");
        //阻塞至最快一个任务执行完成
        info((List<String>) completableFuture.join());
        info("主线程结束");
        executor.shutdown();
    }

• 异常处理

    public static void main(String[] args) {
        ExecutorService executor = new ThreadPoolExecutor(0, Integer.MAX_VALUE, 0, TimeUnit.SECONDS, new SynchronousQueue<Runnable>());
        Supplier<List<String>> task1 = () -> {
            info("task1 begin");
            sleep(1000);
            return new ArrayList() {{ add("1"); }};
        };
        Supplier<List<String>> task2 = () -> {
            info("task2 begin");
            int i = 1/0;
            sleep(1000);
            return new ArrayList() {{ add("2"); }};
        };
        Supplier<List<String>> task3 = () -> {
            info("task3 begin");
            sleep(1000);
            return new ArrayList() {{ add("3"); }};
        };
        BiFunction<List<String>,List<String>,List<String>> combineFunc = (task1Result, task2Result)->{
            info("combine begin");
            task1Result.addAll(task2Result);
            return task1Result;
        };
        //exceptionally可以处理CompletableFuture任务中抛出的异常，可以放在这个链式处理中的任意地方，相当于try catch的范围不一样
        //放在thenCombine(CompletableFuture.supplyAsync(task2,executor).exceptionally(throwable -> {return new ArrayList<>();})，主线程结果main------[1, 3]
        //放在thenCombine(CompletableFuture.supplyAsync(task2,executor),combineFunc).exceptionally(throwable -> {return new ArrayList<>();})，主线程结果main------[3]
        //放在thenCombine(CompletableFuture.supplyAsync(task3,executor),combineFunc).exceptionally(throwable -> {return new ArrayList<>();})，主线程结果main------[]
        CompletableFuture<List<String>> completableFuture = CompletableFuture.supplyAsync(task1,executor)
                .thenCombine(CompletableFuture.supplyAsync(task2,executor),combineFunc)
                .thenCombine(CompletableFuture.supplyAsync(task3,executor),combineFunc).exceptionally(throwable -> {return new ArrayList<>();});
        info(completableFuture.join());
        info("主线程结束");
        executor.shutdown();
    }