CompletableFuture的使用

需求：并行执行两个任务，在两个任务都结束后取执行结果，再进行下一步处理。

首先肯定要用到多线程，需要获取执行结果就要用到Future。百度了下JDK1.8引入的CompletableFuture很适合，他优化了Future，同时避免了Future调用get方法时出现阻塞。另外如果不设置Thread Pool时，他会默认使用ForkJoinPool。

package test.pool;

import java.time.Duration;
import java.time.Instant;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CompletableFutureTest {


    public static void main(String[] args){
        runWithFixedPool(50);
        runWithoutFixedPool(50);
    }

    static void runWithFixedPool(int number) {
        Instant start = Instant.now();

        ExecutorService executor = Executors.newFixedThreadPool(3);
        CompletableFuture<String> a = CompletableFuture.supplyAsync(() -> {
            return printNumber("aaa", number);
        }, executor);

        CompletableFuture<String> b = CompletableFuture.supplyAsync(() -> {
            return printNumber("bbb", number);
        }, executor);

        CompletableFuture<String> c = CompletableFuture.supplyAsync(() -> {
            return printNumber("ccc", number);
        }, executor);

        try {
            System.out.println(a.get());
            System.out.println(b.get());
            System.out.println(c.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        } finally {
            executor.shutdown();
            Instant end = Instant.now();
            System.out.println("execution time - with fixed thread pool: " + Duration.between(start, end).toMillis());
        }
    }

    static void runWithoutFixedPool(int number) {
        Instant start = Instant.now();

        CompletableFuture<String> a = CompletableFuture.supplyAsync(() -> {
            return printNumber("aaa", number);
        });

        CompletableFuture<String> b = CompletableFuture.supplyAsync(() -> {
            return printNumber("bbb", number);
        });

        CompletableFuture<String> c = CompletableFuture.supplyAsync(() -> {
            return printNumber("ccc", number);
        });

        try {
            System.out.println(a.get());
            System.out.println(b.get());
            System.out.println(c.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        } finally {
            Instant end = Instant.now();
            System.out.println("execution time - no thread pool: " + Duration.between(start, end).toMillis());
        }
    }

    static String printNumber(String text, int number) {
        int total = 0;

        for (int i=1; i<= number; i++) {
            total +=i;
            System.out.println(text + ": " + i);
        }

        return text + total;
    }

}

如上例，a、b、c是异步并行执行的。两个方法一个使用了FixThreadPool，另一个用的默认的Pool，默认的Pool执行会更快一些。

50个number：

execution time - with fixed thread pool: 66

execution time - no thread pool: 5

500个number：

execution time - with fixed thread pool: 98

execution time - no thread pool: 20

另外补充一个问题，使用异步方法时，Feign请求的header会丢失，它不会继承总线程的。所以需要先获取到总线程的request数据，再执行异步方法时放入该数据。如下：
 

RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();

......

CompletableFuture<String> a = CompletableFuture.supplyAsync(() -> {
    RequestContextHolder.setRequestAttributes(requestAttributes);
    return printNumber("aaa", number);
});

参考：

https://www.liaoxuefeng.com/wiki/1252599548343744/1306581182447650