使用CompletableFuture进行异步任务编排

1.JDK5引入了Future进行异步任务的处理，Future 的接口主要方法有以下几个：

（1）boolean cancel (boolean mayInterruptIfRunning) 取消任务的执行。参数指定是否立即中断任务执行，或者等等任务结束

（2）boolean isCancelled () 任务是否已经取消，任务正常完成前将其取消，则返回 true

（3）boolean isDone () 任务是否已经完成。需要注意的是如果任务正常终止、异常或取消，都将返回true

（4）V get () throws InterruptedException, ExecutionException 等待任务执行结束，然后获得V类型的结果。InterruptedException 线程被中断异常， ExecutionException任务执行异常，如果任务被取消，还会抛出CancellationException

（5） get (long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException 同上面的get功能一样，多了设置超时时间。参数timeout指定超时时间，uint指定时间的单位，在枚举类TimeUnit中有相关的定义。如果计算超时，将抛出TimeoutException

一般情况下Future 配合Callable 使用，获取异步任务执行的结果，一般使用get()方法设置超时时间，但是在任务执行结束前的这段时间内线程是阻塞的，也就不说异步的了。同时为了获取一般只能采取轮询isDone()方法，这样就显得使用方法很单一，无法适应复杂情况下的异步任务编排。

2.JDK8 引入了CompletableFuture 来进行异步任务的编排，克服了Future的一些缺点，并且且进行了很多扩展。下面对CompletableFuture进行一个小的总结。

3.CompletableFuture 的方法主要有以下几个特点：

（1）以Async结尾的方法都是异步执行的

（2）以run开头的方法一般无返回值，而已supply开头的方法是有返回值的，如 runAsync 和supplyAsync

(3) 以 then 开头的方法都会在上一个任务执行结束之后执行下一个任务。如 thenApply 和 thenAccept

（4）以Accept结尾的方法均为消耗上个任务执行的结果，无返回值。

（5）以run开头的方法忽略上个任务的执行结果，在上个任务执行结束后执行下个方法。

（6）以Executor 结尾的方法可以自定义线程池，如果没有指定线程池，则会默认在ForkJoinPool.commonPool() 线程池中执行。

4.具体实例

(1) 任务执行类的方法

RunAsync 执行异步任务，无返回值

package completablefuture;

import java.util.concurrent.CompletableFuture;

/**
 * @Author lizhilong
 * @create 2019/11/18 18:07
 * @desc
 * runAsyn 无返回结果，执行get()方法时，任务被触发。
 */
public class RunAsync {
    public  static  void  main(String [] args) {
        CompletableFuture<Void> future = CompletableFuture.runAsync(()->{
            System.out.println("Hello");
        });
        System.out.println("--------------");
        try {
            future.get();
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

SupplyAsync 执行异步任务，有返回值

package completablefuture;

import java.util.concurrent.CompletableFuture;
import java.util.function.Supplier;

/**
 * @Author lizhilong
 * @create 2019/11/18 18:17
 * @desc supplyAsync 方法有返回值，在get()方法后被触发
 */
public class SupplyAsync {
    public  static void main(String[] args){
        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(new Supplier<String>() {
            @Override
            public String get() {
                return "Hello";
            }
        });

        System.out.println("-------------");

        try {
            String s = future1.get();
            System.out.println(s);
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

thenApply 在上个方法执行结束后将返回值作为入参执行下个方法。

package completablefuture;

import java.util.concurrent.CompletableFuture;
import java.util.function.Supplier;

/**
 * @Author lizhilong
 * @create 2019/11/18 18:41
 * @desc
 * 以Async结尾的方法都会异步执行
 * thenApply/thenApplyAsync 会在上个方法执行完之后然后继续执行
 */
public class ThenApply {
    public static void main(String[] args) {

        CompletableFuture<String> future = CompletableFuture.supplyAsync(new Supplier<String>() {
            @Override
            public String get() {
                try {
                    Thread.sleep(3000);
                }catch (Exception e){
                    e.printStackTrace();
                }
                return "Hello";
            }
        }).thenApplyAsync(s1 -> {
          return  s1+"=="+"World";
        });

        try {
            String s = future.get();
            System.out.println(s);
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

运行结果

Hello==World

ThenAccept 消耗上个任务执行的结果，无返回值。

package completablefuture;

import java.util.concurrent.CompletableFuture;
import java.util.function.Supplier;

/**
 * @Author lizhilong
 * @create 2019/11/18 19:20
 * @desc
 * thenAccept 对上个任务产生的结果进行消耗，与ThenApply 不同的是无返回结果
 * 所以第二个thenAccept 返回 null
 */
public class ThenAccept {
    public static void main(String[] args) {
        CompletableFuture<Void> future = CompletableFuture.supplyAsync(new Supplier<String>() {
            @Override
            public String get() {
                return "hello";
            }
        }).thenAccept(s1 -> System.out.println(s1+" world"))
                .thenAccept(s2-> System.out.println("---"+s2));

        try {
            future.get();
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

执行结果：

hello world
---null

ThenRun 不关心上一步的执行结果，在上一步任务执行结束后执行下一步任务

package completablefuture;

import java.util.concurrent.CompletableFuture;
import java.util.function.Supplier;

/**
 * @Author lizhilong
 * @create 2019/11/19 11:44
 * @desc thenRun 不关心上一步执行的结果，上一步执行结束后执行下一步
 * thenRunAsync 异步执行
 */
public class ThenRun {

    public static void main(String[] args) {
        CompletableFuture<Void> future = CompletableFuture.supplyAsync(new Supplier<String>() {
            @Override
            public String get() {
                try {
                    Thread.sleep(3000);
                }catch (Exception e){
                    e.printStackTrace();
                }
                return "Hello";
            }
        }).thenRunAsync(new Runnable() {
            @Override
            public void run() {
                System.out.println("World");
            }
        });

        try {
            future.get();
        }catch (Exception e ){
            e.printStackTrace();
        }

    }
}

运行结果：

World

ThenApplyWithExecutor 在自定义的线程池执行异步任务

package completablefuture;

import java.util.concurrent.*;

/**
 * @Author lizhilong
 * @create 2019/11/18 18:59
 * @desc
 * 自定义线程池的方式来处理有先后顺序的任务
 */
public class ThenApplyWithExecutor {

    public static void main(String[] args) {
        ExecutorService service = Executors.newCachedThreadPool();

        CompletableFuture<String> future = CompletableFuture.supplyAsync(()->{
            return "Hello";
        },service).thenApplyAsync(s1->{
            return s1 + "   World";
        },service).thenApplyAsync(s2 ->{
            return s2 +"    China";
        },service);

        try {
            String s = future.get();
            System.out.println(s);
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            service.shutdownNow();
        }
    }
}

运行结果：

Hello   World    China

runAfterBoth/runAfterBothAsync 在前面任务执行结束后执行新的任务

package completablefuture;

import java.util.concurrent.CompletableFuture;
import java.util.function.Supplier;

/**
 * @Author lizhilong
 * @create 2019/11/19 15:33
 * @desc runAfterBothAsync 忽略前面任务的执行结果，在前面任务执行结束之后在执行后面的runable任务
 */
public class RunAfterBothAsync {
    public static void main(String[] args) {
        CompletableFuture<Void> future = CompletableFuture.supplyAsync(new Supplier<String>() {
            @Override
            public String get() {
                try {
                    Thread.sleep(3000);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                System.out.println("st1 end");
                return "Hello";
            }
        }).runAfterBothAsync(CompletableFuture.supplyAsync(new Supplier<String>() {
            @Override
            public String get() {
                try {
                    Thread.sleep(7000);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                System.out.println("st2 end");
                return "World";
            }
        }), new Runnable() {
            @Override
            public void run() {
                System.out.println("I LOVE CHINA");
            }
        });

        try {
            future.get();
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

运行结果：

st1 end
st2 end
I LOVE CHINA

（2）任务结果消费/组合

thenCombine/thenCombineAsync 任务的运行结果进行组合后输出

package completablefuture;

import java.util.concurrent.CompletableFuture;
import java.util.function.Supplier;

/**
 * @Author lizhilong
 * @create 2019/11/19 13:40
 * @desc thenCombineAsync 将任务的执行结果进行合并后输出
 * 最后的合并必操作须等两个任务都执行结束后才可以进行
 */
public class CompletionStage {

    public static void main(String[] args) {
        CompletableFuture<String> future = CompletableFuture.supplyAsync(new Supplier<String>() {
            @Override
            public String get() {
                try {
                    Thread.sleep(3000);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                System.out.println("st1 end");
                return "Hello";
            }
        }).thenCombineAsync(
                CompletableFuture.supplyAsync(new Supplier<String>() {
                                                  @Override
                                                  public String get() {
                                                      try {
                                                          Thread.sleep(7000);
                                                      } catch (Exception e) {
                                                          e.printStackTrace();
                                                      }
                                                      System.out.println("st2 end");
                                                      return "World";
                                                  }
                                              }
                ), (r1, r2) -> r1 + " " + r2);

        try {
            String s = future.get();
            System.out.println(s);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

运行结果：

st1 end
st2 end
Hello World

ThenAcceptBothAsync 对异步任务的执行结果进行消耗，无返回值

package completablefuture;

import java.util.concurrent.CompletableFuture;
import java.util.function.Supplier;

/**
 * @Author lizhilong
 * @create 2019/11/19 14:59
 * @desc thenAcceptBothAsync 消费任务的执行结果，无返回值
 * 消费动作的执行发生在任务均完成的情况下
 */
public class ThenAcceptBothAsync {
    public static void main(String[] args) {
        CompletableFuture<Void> future = CompletableFuture.supplyAsync(new Supplier<String>() {
            @Override
            public String get() {
                try {
                    Thread.sleep(3000);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                System.out.println("st1 end");
                return "Hello";
            }
        }).thenAcceptBothAsync(CompletableFuture.supplyAsync(new Supplier<String>() {
            @Override
            public String get() {
                try {
                    Thread.sleep(7000);
                }catch (Exception e){
                    e.printStackTrace();
                }
                System.out.println("st2 end");
                return "World";
            }
        }) ,(r1, r2) -> System.out.println(r1 +" "+r2));

        try {
            future.get();
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

运行结果：

st1 end
st2 end
Hello World

（3）根据任务执行完成的先后顺讯进行后续操作

applyToEither/applyToEitherAsync 获取最先执行完成的任务的结果

package completablefuture;

import java.util.concurrent.CompletableFuture;
import java.util.function.Supplier;

/**
 * @Author lizhilong
 * @create 2019/11/19 15:43
 * @desc ApplyToEitherAsync 获取多个任务执行最快的任务结果
 */
public class ApplyToEitherAsync {
    public static void main(String[] args) {
        CompletableFuture<String> future = CompletableFuture.supplyAsync(new Supplier<String>() {
            @Override
            public String get() {
                try {
                    Thread.sleep(3000);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                System.out.println("st1 end");
                return "CHINA";
            }
        }).applyToEitherAsync(CompletableFuture.supplyAsync(new Supplier<String>() {
            @Override
            public String get() {
                try {
                    Thread.sleep(7000);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                System.out.println("st2 end");
                return "AUS";
            }
        }), (r) -> {
            return r;
        }).applyToEitherAsync(CompletableFuture.supplyAsync(new Supplier<String>() {
            @Override
            public String get() {
                try {
                    Thread.sleep(2000);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                System.out.println("st3 end");
                return "UK";
            }
        }), r1->{
            return  r1;
        });

        try {
            String s = future.get();
            System.out.println(s);
        }catch (Exception e){
            e.printStackTrace();
        }

    }
}

运行结果：

st3 end
UK

acceptEither/acceptEitherAsync 消耗最先执行完的任务的返回结果

package completablefuture;

import java.util.concurrent.CompletableFuture;
import java.util.function.Supplier;

/**
 * @Author lizhilong
 * @create 2019/11/19 16:13
 * @desc AcceptEitherAsync 消费最先完成的任务返回的结果
 */
public class AcceptEitherAsync {

    public static void main(String[] args) throws  Exception{
        CompletableFuture.supplyAsync(new Supplier<String>() {
            @Override
            public String get() {
                try {
                    Thread.sleep(3000);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                return "Hello";
            }
        }).acceptEitherAsync( CompletableFuture.supplyAsync(new Supplier<String>() {
            @Override
            public String get() {
                try {
                    Thread.sleep(5000);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                return "World";
            }
        }), System.out::println).get();
    }
}

运行结果：

Hello

RunAfterEither/RunAfterEitherAsync 在前面的任务有任何一个完成后运行

package completablefuture;

import java.util.concurrent.CompletableFuture;
import java.util.function.Supplier;

/**
 * @Author lizhilong
 * @create 2019/11/19 18:28
 * @desc RunAfterEither 是在前面任务有一个完成以后再去执行的，即最先完成的任务后运行
 *
 */
public class RunAfterEither {
    public static void main(String[] args) throws  Exception{
        CompletableFuture.supplyAsync(new Supplier<String>() {
            @Override
            public String get() {
                try {
                    Thread.sleep(3000);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                System.out.println("st1 end");
                return "Hello";
            }
        }).runAfterEitherAsync(CompletableFuture.supplyAsync(new Supplier<String>() {
            @Override
            public String get() {
                try {
                    Thread.sleep(5000);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                System.out.println("st2 end");
                return "World";
            }
        }), new Runnable() {
            @Override
            public void run() {
                System.out.println("I LOVE CHINA");
            }
        }).get();
    }
}

运行结果：

st1 end
I LOVE CHINA

（4）任务完成时

complete 任务完成后执行后续操作

package completablefuture;

import java.util.concurrent.CompletableFuture;

/**
 * @Author lizhilong
 * @create 2019/11/18 18:21
 * @desc 任务完成以后 执行后续操作
 */
public class Complete {

    public static void main(String[] args) {
        CompletableFuture<String> future = CompletableFuture.supplyAsync(()->{
           return  "Hello";
        });

        future.complete("world");
        System.out.println("----------------");
        try {
            String s = future.get();
            System.out.println(s);

        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

运行结果：

----------------
world

whenCompleteAsync/whenComplete 在前面任务执行完成后执行后续操作，可以获取前面任务的执行结果和异常

package completablefuture;

import java.util.concurrent.CompletableFuture;
import java.util.function.Supplier;

/**
 * @Author lizhilong
 * @create 2019/11/19 18:46
 * @desc WhenComplete 任务完成后执行相应操作，可以获取上步任务执行的结果或者异常
 */
public class WhenComplete {

    public static void main(String[] args) {
        CompletableFuture<String> future = CompletableFuture.supplyAsync(new Supplier<String>() {
            @Override
            public String get() {
                if (1==2) {
                    throw new RuntimeException("测试异常");
                }
                return "Hello";
            }
        }).whenCompleteAsync((s, e) -> {
            System.out.println(s);
            System.out.println(e.getMessage());
        });

        try {
            String s = future.get();
            System.out.println(s);
        }catch (Exception e){
            System.out.println(e.getMessage());
        }
    }
}

运行结果：

Hello
java.lang.NullPointerException

（5）任务执行异常

completeExceptionally 任务完成后抛异常

package completablefuture;

import java.util.concurrent.CompletableFuture;
import java.util.function.Supplier;

/**
 * @Author lizhilong
 * @create 2019/11/18 18:30
 * @desc 任务完成以后抛异常
 */
public class CompleteExceptionally {
    public static void main(String[] args) {
        CompletableFuture<String> future = CompletableFuture.supplyAsync(new Supplier<String>() {
            @Override
            public String get() {
                return "Hello";
            }
        });

        future.completeExceptionally( new Exception());
        try {
            String s = future.get();
            System.out.println(s);
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

运行结果：

java.util.concurrent.ExecutionException: java.lang.Exception
    at java.util.concurrent.CompletableFuture.reportGet(CompletableFuture.java:357)
    at java.util.concurrent.CompletableFuture.get(CompletableFuture.java:1895)
    at completablefuture.CompleteExceptionally.main(CompleteExceptionally.java:22)
Caused by: java.lang.Exception
    at completablefuture.CompleteExceptionally.main(CompleteExceptionally.java:20)

exceptionally 执行任务过程中产生异常

package completablefuture;

import java.util.concurrent.CompletableFuture;
import java.util.function.Supplier;

/**
 * @Author lizhilong
 * @create 2019/11/19 18:35
 * @desc 任务产生异常时进行相应操作
 */
public class Exceptionally {

    public static void main(String[] args) {
        CompletableFuture<String> future = CompletableFuture.supplyAsync(new Supplier<String>() {
            @Override
            public String get() {
                int x = 10 / 0;
                return "Hello";
            }
        }).exceptionally(e -> {
            System.out.println(e.getMessage());
            return "World";
        });

        try {
            String s = future.get();
            System.out.println(s);
        }catch (Exception e){

        }
    }
}

运行结果：

java.lang.ArithmeticException: / by zero
World

handleAsync/handle 在使用 exceptionally 可以获取异常时的异常，但是无法获取正常执行时的结果

异常：

 public static void main(String[] args) {
        CompletableFuture<String> future = CompletableFuture.supplyAsync(new Supplier<String>() {
            @Override
            public String get() {
                if(true){
                    throw  new RuntimeException("测试异常");
                }
                return "Hello";
            }
        }).handleAsync((r, e) -> {
            if (e != null) {
                return e.getMessage();
            }
            return "World";
        });

        try {
            System.out.println(future.get());
        }catch (Exception e){
            e.printStackTrace();
        }
    }

执行结果：

java.lang.RuntimeException: 测试异常

正常：

package completablefuture;

import java.util.concurrent.CompletableFuture;
import java.util.function.Supplier;

/**
 * @Author lizhilong
 * @create 2019/11/19 18:58
 * @desc
 */
public class HandleNormal {
    public static void main(String[] args) {
        CompletableFuture<String> future = CompletableFuture.supplyAsync(new Supplier<String>() {
            @Override
            public String get() {
                return "Hello";
            }
        }).handleAsync((r, e) -> {
            if (e != null) {
                return e.getMessage();
            }
            return "World";
        });

        try {
            System.out.println(future.get());
        }catch (Exception e){
            e.printStackTrace();
        }
    }

}

执行结果：

World

使用CompletableFuture进行异步任务编排

猜你喜欢