并发编程之CompletableFuture例子详解

public static void main(String[] args) throws ExecutionException, InterruptedException {
ExecutorService executor = Executors.newFixedThreadPool(5);
long time1 = System.currentTimeMillis()/1000;

// demo1(executor);

// demo2(executor);

// demo3(executor);

    demo4(executor);


    long time2 = System.currentTimeMillis()/1000;
    System.out.println(time2-time1+"秒");
    executor.shutdownNow();
}

/**
 * 任务1 作为任务2的入参转换数据  任务2的返回值和任务3的返回值进行组合
 * @param executor
 */
private static void demo4(ExecutorService executor) {
    String result = CompletableFuture.supplyAsync(() -> {
        return task1();
    },executor).thenApplyAsync(v ->
            v+" "+task2()
    ).thenCombine(CompletableFuture.supplyAsync(()->{
        return task3();
    },executor),(s,s3)->{
        return s+ " " +s3;
    }).join();
    System.out.println(result);
}

/**
 * 任务1的返回值 是任务2的入参  返回结果是转换后的值
 * @param executor
 */
private static void demo3(ExecutorService executor) {
    String result = CompletableFuture.supplyAsync(() -> {
        return task1();
    },executor).thenApplyAsync(v ->
            v+" "+task2()
    ).join();
    System.out.println(result);
}

/**
 * 3个任务并行执行
 * @param executor
 * @throws InterruptedException
 * @throws ExecutionException
 */
private static void demo2(ExecutorService executor) throws InterruptedException, ExecutionException {
    CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
        return task1();
    }, executor);
    CompletableFuture<String>future2 = CompletableFuture.supplyAsync(() -> {
        return task2();
    }, executor);
    CompletableFuture<String>future3 = CompletableFuture.supplyAsync(() -> {
        return task3();
    }, executor);
    CompletableFuture<Void> future = CompletableFuture.allOf(future1, future2, future3);
    String s1 = future1.get();
    String s2 = future2.get();
    String s3 = future3.get();
    System.out.println(s1+" "+s2+" "+s3);
}


/**
 * 3任务 需要 1 和 2 结果 完成逻辑
 * @param executor
 */
private static void demo1(ExecutorService executor) {
    String result = CompletableFuture.supplyAsync(() -> {
        return task1();
    },executor).thenCombine(CompletableFuture.supplyAsync(()->{
        return task2();
    },executor),(s1,s2)->{
        String s3 = task3();
        return s1 + " " + s2+ " " +s3;
    }).join();
    System.out.println(result);

}


public static String task1() {
    try {
        Thread.sleep(2000);
        System.out.println("task 1 doing...");
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    return "a";
}

public static String task2() {
    try {
        Thread.sleep(1000);
        System.out.println("task 2 doing...");
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    return "b";
}

public static String task3() {
    try {
        Thread.sleep(3000);
        System.out.println("task 3 doing...");
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    return "c";
}