CompletableFuture简单用法

package com.dangdang.yyip.utils;

import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.google.common.collect.Streams;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.function.BiFunction;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * Created by 
 * Date :2020/9/14
 * Description :
 * Version :1.0
 */
public class CompletableFutureTest {

    public static void main(String[] args) {
        //创建一个有给定结果并完成的CompletableFuture
        CompletableFuture<String> completableFuture = CompletableFuture.completedFuture("test");
        try {
            System.out.println(completableFuture.get());//test
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
        System.out.println(completableFuture.join());//test

        //有返回值
        completableFuture = CompletableFuture.supplyAsync(() -> {
            System.out.println("------------supply---------------");
            System.out.println("-------" + Thread.currentThread().getName());
            return "supply";
        });
        System.out.println(completableFuture.join());

        //无返回值
        CompletableFuture<?> completableFutureRunnable =
                CompletableFuture.runAsync(() -> System.out.println("---------runnable---------"));

        //anyOf  allOf
        CompletableFuture<Integer> c1 = CompletableFuture.supplyAsync(() -> {
            System.out.println("-------------c1------------");
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return 10;
        });
        CompletableFuture<Integer> c2 = CompletableFuture.supplyAsync(() -> {
            System.out.println("-------------c2------------");
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return 100;
        });

        CompletableFuture<Object> anyOf = CompletableFuture.anyOf(c1, c2);
        System.out.println(anyOf.join());//10

        CompletableFuture<Void> allOf = CompletableFuture.allOf(c1, c2);
        System.out.println(allOf.join());//null

        //
        c1.thenRun(() -> System.out.println("-----thenRun----"));
        //c1结果作为入参
        c1.thenAccept(t -> System.out.println("thenApply:c1结果作为入参，无返回值" + t));
        //c1结果作为入参并有返回值
        CompletableFuture<Integer> thenApply = c1.thenApply(t -> {
            System.out.println("thenApply:c1结果作为入参，有返回值" + t);
            return 200;
        });
        System.out.println(thenApply.join());

        /**
         * CompletableFuture<Object> combine = c1.thenCombine(c2, new BiFunction<Integer, Integer, Object>() {
         *             @Override
         *             public Object apply(Integer integer, Integer integer2) {
         *                 return integer + integer2;
         *             }
         *         });
         */
        CompletableFuture<Object> combine = c1.thenCombine(c2, Integer::sum);
        System.out.println("------combine" + combine.join());
        System.out.println(c1.thenCombine(c2, Integer::compareTo).join());//-1
        System.out.println(c2.thenCombine(c1, Integer::compareTo).join());//1

        //thenCompose会连接两个CompletableFuture，其处理是当前CompletableFuture完成时将结果作为fn处理的入参进行处理。
        CompletableFuture<Integer> compose = c1.thenCompose(t -> {
            System.out.println("---------------compose" + t);
            return c2.thenApply(m -> {
                System.out.println("thenApply:c1结果作为入参，有返回值" + m + " " + t);
                return 200 + m + t;
            });
        });
        System.out.println(compose.join());//100


//        c1.whenComplete();

        test();
    }

    public static void test() {
        List<Integer> list = Arrays.asList(1,2,3,4);
        List<CompletableFuture<Map<String, Object>>> futures = Lists.newArrayList();
        list.parallelStream().forEach(t -> {
            CompletableFuture<Integer> defaultFuture = CompletableFuture.completedFuture(t);
            CompletableFuture<Map<String, Object>> completableFuture =
                    defaultFuture.thenApplyAsync(CompletableFutureTest::method);
            futures.add(completableFuture);
        });
        System.out.println("-------------------异步----------------");
        CompletableFuture[] array = futures.toArray(new CompletableFuture[0]);
        CompletableFuture<List<Object>> listCompletableFuture = CompletableFuture.allOf(array)
                .thenApply(ignore -> Stream.of(array)
                        .map(CompletableFuture::join)
                        .collect(Collectors.toList()));
        System.out.println("=============================");
        System.out.println(listCompletableFuture.join());
    }

    public static Map<String, Object> method(Integer param) {
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("-------------===============---------------" + param);
        Map<String, Object> map = Maps.newHashMap();
        map.put("key:" + param, "value:" + param);
        return map;
    }
}