CompletableFuture 使用详解

原文地址：https://cloud.tencent.com/developer/article/1352540

1、 runAsync 和 supplyAsync方法

CompletableFuture 提供了四个静态方法来创建一个异步操作。

public static CompletableFuture runAsync(Runnable runnable)
public static CompletableFuture runAsync(Runnable runnable, Executor executor)
public static  CompletableFuture supplyAsync(Supplier supplier)
public static  CompletableFuture supplyAsync(Supplier supplier, Executor executor)

没有指定Executor的方法会使用ForkJoinPool.commonPool() 作为它的线程池执行异步代码。如果指定线程池，则使用指定的线程池运行。以下所有的方法都类同。

• runAsync方法不支持返回值。
• supplyAsync可以支持返回值。

示例

//无返回值
public static void runAsync() throws Exception {
    CompletableFuture future = CompletableFuture.runAsync(() -> {
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
        }
        System.out.println("run end ...");
    });
    
    future.get();
}

//有返回值
public static void supplyAsync() throws Exception {         
    CompletableFuture future = CompletableFuture.supplyAsync(() -> {
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
        }
        System.out.println("run end ...");
        return System.currentTimeMillis();
    });

    long time = future.get();
    System.out.println("time = "+time);
}

2、计算结果完成时的回调方法

当CompletableFuture的计算结果完成，或者抛出异常的时候，可以执行特定的Action。主要是下面的方法：

public CompletableFuture whenComplete(BiConsumer action)
public CompletableFuture whenCompleteAsync(BiConsumer action)
public CompletableFuture whenCompleteAsync(BiConsumer action, Executor executor)
public CompletableFuture exceptionally(Function fn)

可以看到Action的类型是BiConsumer它可以处理正常的计算结果，或者异常情况。

whenComplete 和 whenCompleteAsync 的区别： whenComplete：是执行当前任务的线程执行继续执行 whenComplete 的任务。 whenCompleteAsync：是执行把 whenCompleteAsync 这个任务继续提交给线程池来进行执行。

示例

public static void whenComplete() throws Exception {
    CompletableFuture future = CompletableFuture.runAsync(() -> {
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
        }
        if(new Random().nextInt()%2>=0) {
            int i = 12/0;
        }
        System.out.println("run end ...");
    });
    
    future.whenComplete(new BiConsumer() {
        @Override
        public void accept(Void t, Throwable action) {
            System.out.println("执行完成！");
        }
        
    });
    future.exceptionally(new Function() {
        @Override
        public Void apply(Throwable t) {
            System.out.println("执行失败！"+t.getMessage());
            return null;
        }
    });
    
    TimeUnit.SECONDS.sleep(2);
}

3、 thenApply 方法

当一个线程依赖另一个线程时，可以使用 thenApply 方法来把这两个线程串行化。

public  CompletableFuture thenApply(Function fn)
public  CompletableFuture thenApplyAsync(Function fn)
public  CompletableFuture thenApplyAsync(Function fn, Executor executor)

Function T：上一个任务返回结果的类型 U：当前任务的返回值类型

示例

private static void thenApply() throws Exception {
    CompletableFuture future = CompletableFuture.supplyAsync(new Supplier() {
        @Override
        public Long get() {
            long result = new Random().nextInt(100);
            System.out.println("result1="+result);
            return result;
        }
    }).thenApply(new Function() {
        @Override
        public Long apply(Long t) {
            long result = t*5;
            System.out.println("result2="+result);
            return result;
        }
    });
    
    long result = future.get();
    System.out.println(result);
}

第二个任务依赖第一个任务的结果。

4、 handle 方法

handle 是执行任务完成时对结果的处理。 handle 方法和 thenApply 方法处理方式基本一样。不同的是 handle 是在任务完成后再执行，还可以处理异常的任务。thenApply 只可以执行正常的任务，任务出现异常则不执行 thenApply 方法。

public  CompletionStage handle(BiFunction fn);
public  CompletionStage handleAsync(BiFunction fn);
public  CompletionStage handleAsync(BiFunction fn,Executor executor);

示例

public static void handle() throws Exception{
    CompletableFuture future = CompletableFuture.supplyAsync(new Supplier() {

        @Override
        public Integer get() {
            int i= 10/0;
            return new Random().nextInt(10);
        }
    }).handle(new BiFunction() {
        @Override
        public Integer apply(Integer param, Throwable throwable) {
            int result = -1;
            if(throwable==null){
                result = param * 2;
            }else{
                System.out.println(throwable.getMessage());
            }
            return result;
        }
     });
    System.out.println(future.get());
}

从示例中可以看出，在 handle 中可以根据任务是否有异常来进行做相应的后续处理操作。而 thenApply 方法，如果上个任务出现错误，则不会执行 thenApply 方法。

5、 thenAccept 消费处理结果

接收任务的处理结果，并消费处理，无返回结果。

public CompletionStage thenAccept(Consumer action);
public CompletionStage thenAcceptAsync(Consumer action);
public CompletionStage thenAcceptAsync(Consumer action,Executor executor);

示例

public static void thenAccept() throws Exception{
    CompletableFuture future = CompletableFuture.supplyAsync(new Supplier() {
        @Override
        public Integer get() {
            return new Random().nextInt(10);
        }
    }).thenAccept(integer -> {
        System.out.println(integer);
    });
    future.get();
}

从示例代码中可以看出，该方法只是消费执行完成的任务，并可以根据上面的任务返回的结果进行处理。并没有后续的输错操作。

6、thenRun 方法

跟 thenAccept 方法不一样的是，不关心任务的处理结果。只要上面的任务执行完成，就开始执行 thenAccept 。

public CompletionStage thenRun(Runnable action);
public CompletionStage thenRunAsync(Runnable action);
public CompletionStage thenRunAsync(Runnable action,Executor executor);

示例

public static void thenRun() throws Exception{
    CompletableFuture future = CompletableFuture.supplyAsync(new Supplier() {
        @Override
        public Integer get() {
            return new Random().nextInt(10);
        }
    }).thenRun(() -> {
        System.out.println("thenRun ...");
    });
    future.get();
}

该方法同 thenAccept 方法类似。不同的是上个任务处理完成后，并不会把计算的结果传给 thenRun 方法。只是处理玩任务后，执行 thenAccept 的后续操作。

7、thenCombine 合并任务

thenCombine 会把 两个 CompletionStage 的任务都执行完成后，把两个任务的结果一块交给 thenCombine 来处理。

public  CompletionStage thenCombine(CompletionStage other,BiFunction fn);
public  CompletionStage thenCombineAsync(CompletionStage other,BiFunction fn);
public  CompletionStage thenCombineAsync(CompletionStage other,BiFunction fn,Executor executor);

示例

private static void thenCombine() throws Exception {
    CompletableFuture future1 = CompletableFuture.supplyAsync(new Supplier() {
        @Override
        public String get() {
            return "hello";
        }
    });
    CompletableFuture future2 = CompletableFuture.supplyAsync(new Supplier() {
        @Override
        public String get() {
            return "hello";
        }
    });
    CompletableFuture result = future1.thenCombine(future2, new BiFunction() {
        @Override
        public String apply(String t, String u) {
            return t+" "+u;
        }
    });
    System.out.println(result.get());
}

8、thenAcceptBoth

当两个CompletionStage都执行完成后，把结果一块交给thenAcceptBoth来进行消耗

public  CompletionStage thenAcceptBoth(CompletionStage other,BiConsumer action);
public  CompletionStage thenAcceptBothAsync(CompletionStage other,BiConsumer action);
public  CompletionStage thenAcceptBothAsync(CompletionStage other,BiConsumer action,     Executor executor);

示例

private static void thenAcceptBoth() throws Exception {
    CompletableFuture f1 = CompletableFuture.supplyAsync(new Supplier() {
        @Override
        public Integer get() {
            int t = new Random().nextInt(3);
            try {
                TimeUnit.SECONDS.sleep(t);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("f1="+t);
            return t;
        }
    });
        
    CompletableFuture f2 = CompletableFuture.supplyAsync(new Supplier() {
        @Override
        public Integer get() {
            int t = new Random().nextInt(3);
            try {
                TimeUnit.SECONDS.sleep(t);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("f2="+t);
            return t;
        }
    });
    f1.thenAcceptBoth(f2, new BiConsumer() {
        @Override
        public void accept(Integer t, Integer u) {
            System.out.println("f1="+t+";f2="+u+";");
        }
    });
}

9、applyToEither 方法

两个CompletionStage，谁执行返回的结果快，我就用那个CompletionStage的结果进行下一步的转化操作。

public  CompletionStage applyToEither(CompletionStage other,Function fn);
public  CompletionStage applyToEitherAsync(CompletionStage other,Function fn);
public  CompletionStage applyToEitherAsync(CompletionStage other,Function fn,Executor executor);

示例

private static void applyToEither() throws Exception {
    CompletableFuture f1 = CompletableFuture.supplyAsync(new Supplier() {
        @Override
        public Integer get() {
            int t = new Random().nextInt(3);
            try {
                TimeUnit.SECONDS.sleep(t);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("f1="+t);
            return t;
        }
    });
    CompletableFuture f2 = CompletableFuture.supplyAsync(new Supplier() {
        @Override
        public Integer get() {
            int t = new Random().nextInt(3);
            try {
                TimeUnit.SECONDS.sleep(t);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("f2="+t);
            return t;
        }
    });
    
    CompletableFuture result = f1.applyToEither(f2, new Function() {
        @Override
        public Integer apply(Integer t) {
            System.out.println(t);
            return t * 2;
        }
    });

    System.out.println(result.get());
}

10、acceptEither 方法

两个CompletionStage，谁执行返回的结果快，我就用那个CompletionStage的结果进行下一步的消耗操作。

public CompletionStage acceptEither(CompletionStage other,Consumer action);
public CompletionStage acceptEitherAsync(CompletionStage other,Consumer action);
public CompletionStage acceptEitherAsync(CompletionStage other,Consumer action,Executor executor);

示例

private static void acceptEither() throws Exception {
    CompletableFuture f1 = CompletableFuture.supplyAsync(new Supplier() {
        @Override
        public Integer get() {
            int t = new Random().nextInt(3);
            try {
                TimeUnit.SECONDS.sleep(t);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("f1="+t);
            return t;
        }
    });
        
    CompletableFuture f2 = CompletableFuture.supplyAsync(new Supplier() {
        @Override
        public Integer get() {
            int t = new Random().nextInt(3);
            try {
                TimeUnit.SECONDS.sleep(t);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("f2="+t);
            return t;
        }
    });
    f1.acceptEither(f2, new Consumer() {
        @Override
        public void accept(Integer t) {
            System.out.println(t);
        }
    });
}

11、runAfterEither 方法

两个CompletionStage，任何一个完成了都会执行下一步的操作（Runnable）

public CompletionStage runAfterEither(CompletionStage other,Runnable action);
public CompletionStage runAfterEitherAsync(CompletionStage other,Runnable action);
public CompletionStage runAfterEitherAsync(CompletionStage other,Runnable action,Executor executor);

示例

private static void runAfterEither() throws Exception {
    CompletableFuture f1 = CompletableFuture.supplyAsync(new Supplier() {
        @Override
        public Integer get() {
            int t = new Random().nextInt(3);
            try {
                TimeUnit.SECONDS.sleep(t);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("f1="+t);
            return t;
        }
    });
        
    CompletableFuture f2 = CompletableFuture.supplyAsync(new Supplier() {
        @Override
        public Integer get() {
            int t = new Random().nextInt(3);
            try {
                TimeUnit.SECONDS.sleep(t);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("f2="+t);
            return t;
        }
    });
    f1.runAfterEither(f2, new Runnable() {
        
        @Override
        public void run() {
            System.out.println("上面有一个已经完成了。");
        }
    });
}

12、runAfterBoth

两个CompletionStage，都完成了计算才会执行下一步的操作（Runnable）

public CompletionStage runAfterBoth(CompletionStage other,Runnable action);
public CompletionStage runAfterBothAsync(CompletionStage other,Runnable action);
public CompletionStage runAfterBothAsync(CompletionStage other,Runnable action,Executor executor);

示例

private static void runAfterBoth() throws Exception {
    CompletableFuture f1 = CompletableFuture.supplyAsync(new Supplier() {
        @Override
        public Integer get() {
            int t = new Random().nextInt(3);
            try {
                TimeUnit.SECONDS.sleep(t);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("f1="+t);
            return t;
        }
    });
        
    CompletableFuture f2 = CompletableFuture.supplyAsync(new Supplier() {
        @Override
        public Integer get() {
            int t = new Random().nextInt(3);
            try {
                TimeUnit.SECONDS.sleep(t);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("f2="+t);
            return t;
        }
    });
    f1.runAfterBoth(f2, new Runnable() {
        
        @Override
        public void run() {
            System.out.println("上面两个任务都执行完成了。");
        }
    });
}

13、thenCompose 方法

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

public  CompletableFuture thenCompose(Function> fn);
public  CompletableFuture thenComposeAsync(Function> fn) ;
public  CompletableFuture thenComposeAsync(Function> fn, Executor executor) ;

示例

private static void thenCompose() throws Exception {
        CompletableFuture f = CompletableFuture.supplyAsync(new Supplier() {
            @Override
            public Integer get() {
                int t = new Random().nextInt(3);
                System.out.println("t1="+t);
                return t;
            }
        }).thenCompose(new Function>() {
            @Override
            public CompletionStage apply(Integer param) {
                return CompletableFuture.supplyAsync(new Supplier() {
                    @Override
                    public Integer get() {
                        int t = param *2;
                        System.out.println("t2="+t);
                        return t;
                    }
                });
            }
            
        });
        System.out.println("thenCompose result : "+f.get());
    }

 

 

 

实例：

public static void main(String[] args) {
        try {
            Supplier t1 = new Supplier() {
                @Override
                public UserLevelEntity get() {
                    UserLevelEntity u1 = new UserLevelEntity();
                    u1.setUser_id("1").setUser_name("cn_yaojin").setParent_id("");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    return u1;
                }
            };

            Supplier t2 = new Supplier() {
                @Override
                public UserLevelEntity get() {
                    UserLevelEntity u2 = new UserLevelEntity();
                    u2.setUser_id("1");
                    u2.setScore_info1(10);
                    try {
                        Thread.sleep(5000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    return u2;
                }
            };
            //模拟执行查询操作1
            CompletableFuture f1 = CompletableFuture.supplyAsync(t1);
            //模拟执行查询操作2
            CompletableFuture f2 = CompletableFuture.supplyAsync(t2);

            //将以上2步的查询结果合并
            CompletableFuture result = f1.thenCombine(f2, new BiFunction() {
                @Override
                public UserLevelEntity apply(UserLevelEntity userLevelEntity, UserLevelEntity userLevelEntity2) {
                    if(userLevelEntity.getUser_id().equals(userLevelEntity2.getUser_id())){
                        userLevelEntity.setScore_info1(userLevelEntity2.getScore_info1());
                    }
                    return userLevelEntity;
                }
            });
            //合并后的结果
            UserLevelEntity userLevelEntity = result.get(30, TimeUnit.SECONDS);

            if(userLevelEntity==null){
                System.out.println("请求超时");
            }else{
                System.out.println(userLevelEntity.getUser_id()+","+userLevelEntity.getUser_name()+","+userLevelEntity.getScore_info1());
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

 

UserLevelEntity 

package com.fame.userlevel.entity;

import java.io.Serializable;

public class UserLevelEntity implements Serializable {

    private String user_id;

    private String user_name;

    private int score_info1;

    /**
     * 用户级别
     *  0-无效用户 1-有效用户 2-香主 3-堂主 4-长老 5-护法 6-掌门 7-盟主
     */
    private int active_peo;

    private String parent_id;

    private int active_sort_flag;

    public String getUser_id() {
        return user_id;
    }

    public UserLevelEntity setUser_id(String user_id) {
        this.user_id = user_id;
        return this;
    }

    public int getScore_info1() {
        return score_info1;
    }

    public UserLevelEntity setScore_info1(int score_info1) {
        this.score_info1 = score_info1;
        return this;
    }

    public int getActive_peo() {
        return active_peo;
    }

    public UserLevelEntity setActive_peo(int active_peo) {
        this.active_peo = active_peo;
        return this;
    }

    public String getParent_id() {
        return parent_id;
    }

    public UserLevelEntity setParent_id(String parent_id) {
        this.parent_id = parent_id;
        return this;
    }

    public String getUser_name() {
        return user_name;
    }

    public UserLevelEntity setUser_name(String user_name) {
        this.user_name = user_name;
        return this;
    }

    public int getActive_sort_flag() {
        return active_sort_flag;
    }

    public UserLevelEntity setActive_sort_flag(int active_sort_flag) {
        this.active_sort_flag = active_sort_flag;
        return this;
    }
}