CompeletableFuture常用方法的使用介绍

cj_eryue

于 2024-10-31 16:36:21 发布

阅读量741

点赞数 11

分类专栏：并发&JUC 文章标签： windows

本文链接：https://blog.youkuaiyun.com/cj_eryue/article/details/143401058

版权

并发&JUC 专栏收录该内容

14 篇文章

订阅专栏

一、前言

二、CompletableFuture 的使用介绍

2.1、 runAsync

2.1.1、 runAsync（Runnable）

2.1.2、runAsync(Runnable, Executor)

2.2、supplyAsync

2.2.1、supplyAsync(Supplier)

2.2.2、supplyAsync(Supplier , Executor)

2.3 、CompletableFuture中 get 与 join的区别

2.4、thenApply方法

2.4.1、thenApply(Function)

2.4.2、thenApplyAsync(Function)

2.5、handle方法

2.5.1、handle(BiFunction fn),>

2.5.2、handleAsync(BiFunction fn，Executor),>

2.6、thenCombine方法

2.6.1、thenCombine

2.6.2、thenCombineAsync

2.7、thenCompose方法

2.7.1、thenCompose

2.7.2、thenComposeAsync

2.8、allOf / anyOf 方法

一、前言

最近刚好使用CompeletableFuture优化了项目中的代码，所以跟大家一起学习CompletableFuture。

优化场景：有个业务，需要处理不同资源的某个信息，单个资源的信息处理需要二十多秒（第三方功能，无法优化），必须等每个资源的信息处理完成后，才能进行下一步操作，假设现在要处理三个这样的资源信息，如果是串行化执行，则需要60多秒，如下demo：

private static void test() {
        List<Integer> list = Collections.synchronizedList(new ArrayList<>(3));
        long startTime = System.currentTimeMillis();
        // 假设需要处理三个资源的信息
        for (int i = 1; i <= 3; i++) {
            int finalI = i;
            try {
                // 模拟业务操作，等待2秒
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            list.add(finalI);
        }
        System.out.println("result->" + list);
        System.out.println("use time " + (System.currentTimeMillis() - startTime) + "ms");
    }

运行结果：

使用CompeletableFuture优化如下：

private static void completableFuture() throws InterruptedException, ExecutionException {
        List<CompletableFuture<Void>> completableFutures = new ArrayList<>(3);
        List<Integer> list = Collections.synchronizedList(new ArrayList<>(3));
        long startTime = System.currentTimeMillis();
        for (int i = 1; i <= 3; i++) {
            int finalI = i;
            CompletableFuture<Void> cf = CompletableFuture.runAsync(() -> {
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                list.add(finalI);
            });
            completableFutures.add(cf);
        }
        CompletableFuture<Void> allOf = CompletableFuture.allOf(completableFutures.toArray(new CompletableFuture[completableFutures.size()]));
        System.out.println("result->" + allOf.get());
        System.out.println("result->" + list);
        System.out.println("use time " + (System.currentTimeMillis() - startTime) + "ms");
    }

运行结果：

`二、CompletableFuture` 的使用介绍

CompletableFuture 是 Java 8 引入用于支持异步编程和非阻塞操作的类。

主要新增的功能有：

runAsync(): 异步执行，无返回值
supplyAsync(): 异步执行，有返回值
thenAccept(): 当task正常完成后，回调调用
exceptionally(): 当task出现异常是，回调调用
anyOf(): 当所有的task中，只要有一个task完成，则主线程继续往下走，可以使用.anyOf()方法
allOf(): 所有的task均完成后，则主线程继续往下走

2.1、 runAsync

此异步方法无法返回值

2.1.1、 runAsync（Runnable）

使用ForkJoinPool.commonPool()作为它的线程池执行异步代码,

public class AsyncDemo01 {
    public static void main(String[] args) throws InterruptedException {
        //当前调用者线程为:main
        System.out.println("current:" + Thread.currentThread().getName());
        CompletableFuture.runAsync(() -> {
            // 异步方法内当前执行线程为:ForkJoinPool.commonPool-worker-1
            System.out.println("AsyncDemo01:" + Thread.currentThread().getName());
        });
        Thread.sleep(2000);
    }

}

2.1.2、runAsync(Runnable, Executor)

使用指定线程池来执行可获取返回值的异步任务

public class AsyncDemo02 {
    public static void main(String[] args) {
        //当前调用者线程为:main
        System.out.println("current:" + Thread.currentThread().getName());

        // 根据阿里规约 建议真实开发时使用 ThreadPoolExecutor 定义线程池
        ExecutorService threadPool = Executors.newFixedThreadPool(10);

        CompletableFuture.runAsync(() -> {
            // 异步方法内当前执行线程为:pool-1-thread-1
            System.out.println("AsyncDemo02:" + Thread.currentThread().getName());
        }, threadPool);

        // 演示代码，所以选择执行完后关闭线程池
        threadPool.shutdown();
    }
}

2.2、supplyAsync

异步操作有返回值

2.2.1、supplyAsync(Supplier)

使用ForkJoinPool.commonPool()作为它的线程池执行异步代码，异步操作有返回值

public static void main(String[] args) {
        CompletableFuture<String> supplyAsync = CompletableFuture.supplyAsync(() -> {
            // 异步方法内当前执行线程为:ForkJoinPool.commonPool-worker-1
            System.out.println("SupplyDemo01:" + Thread.currentThread().getName());
            // 模拟返回值
            return "hello world";
        });
        // 获取异步线程执行结果
        System.out.println(supplyAsync.join());

    }

2.2.2、supplyAsync(Supplier , Executor)

使用指定线程池来执行可获取返回值的异步任务

public class SupplyDemo02 {
    public static void main(String[] args) {
        // 根据阿里规约 建议真实开发时使用 ThreadPoolExecutor 定义线程池
        ExecutorService threadPool = Executors.newFixedThreadPool(10);
        CompletableFuture<String> supplyAsync = CompletableFuture.supplyAsync(() -> {
            // 异步方法内当前执行线程为:pool-1-thread-1
            System.out.println("SupplyDemo02:" + Thread.currentThread().getName());
            // 模拟耗时与返回结果
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "hello world";
        }, threadPool);
        // 获取异步线程执行结果
        System.out.println(supplyAsync.join());
    }

}

2.3 、CompletableFuture中 get 与 join的区别

CompletableFuture 使用 supplyAsync 来执行异步任务的话，可通过调用 get 或 join方法便可获取异步线程的执行结果。

不同：get方法返回结果，抛出的是检查异常，必须用户throw或者try/catch处理，join返回结果，抛出未检查异常。get 方法有重载，还有一个可传入获取结果等待时间的get方法，如果超过等待时间，异步线程还未返回结果，那么get 调用者线程则会抛出TimeoutException 异常

相同：join和get方法都是依赖于完成信号并返回结果T的阻塞方法。(阻塞调用者线程，等待异步线程返回结果)

2.4、thenApply方法

当我们第二个任务依赖第一个任务的结果的时候，可以使用 thenApply相关方法来把这两个线程串行化，参数是一个Function(代表着我们需要传入一个转换的函数具体可参考JAVA8 函数式接口)thenApply 只可以执行正常的任务，任务出现异常则不会执行 thenApply 方法；如果当第一个任务出现异常时仍要执行第二个任务，可以使用下方的Handle方法。

public <U> CompletableFuture<U> thenApply(Function<? super T,? extends U> fn)
public <U> CompletableFuture<U> thenApplyAsync(Function<? super T,? extends U> fn)
public <U> CompletableFuture<U> thenApplyAsync(Function<? super T,? extends U> fn, Executor executor)

T:上一个异步任务返回值

U: 当前执行最后返回值

2.4.1、thenApply(Function)

thenApply：thenApply中的线程为调用者线程，与CompletableFuture 底层默认所用的 ForkJoin无关！

public class SupplyDemo03 {
    public static void main(String[] args) {
        CompletableFuture<String> future = CompletableFuture
                .supplyAsync(() -> {
                    System.out.println(Thread.currentThread().getName());
                    return "hello";
                }).thenApply(e -> {
                    System.out.println(Thread.currentThread().getName());
                    return e + " ";
                }).thenApply(e -> {
                    System.out.println(Thread.currentThread().getName());
                    return (e + "world").toUpperCase();
                });
        System.out.println(future.join());
    }
}

2.4.2、thenApplyAsync(Function)

当我们第二个任务依赖第一个任务的结果的时候，且第二个任务也想采用异步的方式，则可以使用 thenApplyAsync(Function)

 CompletableFuture<String> future2 = CompletableFuture
                .supplyAsync(() -> {
                    System.out.println(Thread.currentThread().getName());
                    return "hello";
                }).thenApplyAsync(e -> {
                    System.out.println(Thread.currentThread().getName());
                    return e + " ";
                }).thenApplyAsync(e -> {
                    System.out.println(Thread.currentThread().getName());
                    return (e + "world").toUpperCase();
                });
        System.out.println(future2.join());

当然，我们也可以使用 thenApplyAsync(Function, Executor) 来使用自定义线程池执行我们的异步任务。

2.5、handle方法

handle 是执行任务完成时对结果的处理， handle 方法和 thenApply 方法处理方式大致一样，不同的是 handle 是在任务完成后再执行且Handle可以根据可以根据任务是否有异常来进行做相应的后续处理操作。

2.5.1、handle(BiFunction<T, Throwable, U> fn)

使用Handler方法预估异常情况进行逻辑处理默认handle中使用的线程为调用者线程。

public static void main(String[] args) {
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            System.out.println("supplyAsync:" + Thread.currentThread().getName());
            // 模拟异常
            int a = 1 / 0;
            return "hello";
        }).handle((x, t) -> {
            System.out.println("handle:" + Thread.currentThread().getName());
            if (t != null) {
                // 出现异常 打印异常信息 或者doSomething
                System.out.println("exception:" + t.getMessage());
            } else {
                // 未出异常 doSomething
                return x;
            }
            // 设置默认结果
            return "error";
        });
        System.out.println(future.join());
    }

2.5.2、handleAsync(BiFunction<T, Throwable, U> fn，Executor)

使用自定义的线程（或者使用默认的ForkJoin）进行异步处理第二个线程的任务。

public class HandleDemo02 {
    public static void main(String[] args) {
        ExecutorService threadPool = Executors.newFixedThreadPool(2);
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            System.out.println("supplyAsync:" + Thread.currentThread().getName());
            // 模拟异常
            int a = 1 / 0;
            return "hello";
        },threadPool).handleAsync((x, t) -> {
            System.out.println("handle:" + Thread.currentThread().getName());
            if (t != null) {
                // 出现异常 打印异常信息 或者doSomething
                System.out.println("exception:" + t.getMessage());
            } else {
                // 未出异常 doSomething
                return x;
            }
            // 设置默认结果
            return "error";
        },threadPool);
        System.out.println(future.join());
    }
}

2.6、thenCombine方法

thenCombine 会在两个CompletableFuture任务都执行完成后，把两个任务的结果一块处理。

public <U,V> CompletionStage<V> thenCombine(CompletionStage<? extends U> other,BiFunction<? super T,? super U,? extends V> fn);
public <U,V> CompletionStage<V> thenCombineAsync(CompletionStage<? extends U> other,BiFunction<? super T,? super U,? extends V> fn);
public <U,V> CompletionStage<V> thenCombineAsync(CompletionStage<? extends U> other,BiFunction<? super T,? super U,? extends V> fn,Executor executor);

2.6.1、thenCombine

thenCombine 会在两个CompletableFuture任务都执行完成后，调用者线程会把两个异步任务的结果一块处理。

public class ThenCombineDemo01 {
    public static void main(String[] args) {
        CompletableFuture<String> helloAsync = CompletableFuture.supplyAsync(() -> {
            System.out.println("hello thread:" + Thread.currentThread().getName());
            return "hello";
        });
        CompletableFuture<String> worldAsync = CompletableFuture.supplyAsync(() -> {
            System.out.println("world thread:" + Thread.currentThread().getName());
            return "world";
        });
        CompletableFuture<String> result = worldAsync.thenCombine(helloAsync, (hello, world) -> {
            System.out.println("result thread:" + Thread.currentThread().getName());
            return (hello + " " + world).toUpperCase();
        });
        System.out.println("current thread:" + Thread.currentThread().getName());
        System.out.println("result:" + result.join());
    }

}

2.6.2、thenCombineAsync

thenCombineAsync 会在两个CompletableFuture任务都执行完成后，再用一个异步线程把两个任务的结果一块处理。

2.7、thenCompose方法

thenCompose 方法允许你对两个CompletableFuture任务进行流水线操作，当第一个异步任务操作完成时，会将其结果作为参数传递给第二个任务。

public <U> CompletableFuture<U> thenCompose(Function<? super T, ? extends CompletionStage<U>> fn);
public <U> CompletableFuture<U> thenComposeAsync(Function<? super T, ? extends CompletionStage<U>> fn) ;
public <U> CompletableFuture<U> thenComposeAsync(Function<? super T, ? extends CompletionStage<U>> fn, Executor executor) ;

2.7.1、thenCompose

thenCompose当第一个异步任务操作完成时，会将其结果作为参数传递给第二个任务(第二个任务为串行化操作，由调用者线程执行)。

public class ThenComposeDemo01 {
    public static void main(String[] args) {
        CompletableFuture<String> result = CompletableFuture.supplyAsync(() -> {
            System.out.println("hello thread:" + Thread.currentThread().getName());
            return "hello";
        }).thenCompose((hello -> {
            System.out.println("thenCompose thread:" + Thread.currentThread().getName());
            return CompletableFuture.supplyAsync((hello + " " + "world")::toUpperCase);
        }));
        System.out.println("current thread:" + Thread.currentThread().getName());
        System.out.println("result:" + result.join());
    }
}

2.7.2、thenComposeAsync

当第一个异步任务操作完成时，会将其结果作为参数传递给第二个任务(第二个任务仍为异步线程执行操作，可由默认ForkJoin线程池执行，也可使用自定义线程池)。

public class ThenComposeDemo02 {
    public static void main(String[] args) {
        ExecutorService threadPool = Executors.newFixedThreadPool(2);
        CompletableFuture<String> result = CompletableFuture.supplyAsync(() -> {
            System.out.println("hello thread:" + Thread.currentThread().getName());
            return "hello";
        }, threadPool).thenComposeAsync((hello -> {
            System.out.println("thenCompose thread:" + Thread.currentThread().getName());
            return CompletableFuture.supplyAsync((hello + " " + "world")::toUpperCase);
        }), threadPool);
        System.out.println("current thread:" + Thread.currentThread().getName());
        System.out.println("result:" + result.join());
    }
}

2.8、allOf / anyOf 方法

allOf：CompletableFuture是多个任务都执行完成后才会执行。只要有一个任务执行异常，则返回的CompletableFuture执行get方法时会抛出异常，如果都是正常执行，则get返回null。

anyOf ：CompletableFuture是多个任务只要有一个任务执行完成就会执行。所有任务都执行异常，返回的CompletableFuture执行get方法时才会抛出异常，如果都是正常执行，则get返回执行完成任务的结果。

public class AllOfDemo01 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CompletableFuture<String> cf1 = CompletableFuture.supplyAsync(() -> {
            try {
                System.out.println(Thread.currentThread() + " cf1 do something....");
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "cf1 ok";
        });

        CompletableFuture<String> cf2 = CompletableFuture.supplyAsync(() -> {
            try {
                System.out.println(Thread.currentThread() + " cf2 do something....");
                int a = 1/0;
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "cf2 ok";
        });

        CompletableFuture<String> cf3 = CompletableFuture.supplyAsync(() -> {
            try {
                System.out.println(Thread.currentThread() + " cf2 do something....");
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "cf3 ok";
        });

        CompletableFuture<Void> cfAll = CompletableFuture.allOf(cf1, cf2, cf3);
        System.out.println("cfAll->" + cfAll.get());
    }
}

public class AnyOfDemo01 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CompletableFuture<String> cf1 = CompletableFuture.supplyAsync(() -> {
            try {
                System.out.println(Thread.currentThread() + " cf1 do something....");
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "cf1 ok";
        });

        CompletableFuture<String> cf2 = CompletableFuture.supplyAsync(() -> {
            try {
                System.out.println(Thread.currentThread() + " cf2 do something....");
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "cf2 ok";
        });

        CompletableFuture<String> cf3 = CompletableFuture.supplyAsync(() -> {
            try {
                System.out.println(Thread.currentThread() + " cf2 do something....");
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "cf3 ok";
        });

        CompletableFuture<Object> cfAll = CompletableFuture.anyOf(cf1, cf2, cf3);
        System.out.println("cfAll->" + cfAll.get());
    }
}