completable 用法

CompletableFuture

　　前面我们使用过jdk5 提出future的用法,但是在获取结果上并不是那么友好

　　在Java8中，CompletableFuture提供了非常强大的Future的扩展功能，可以帮助我们简化异步编程的复杂性，并且提供了函数式编程的能力，可以通过回调的方式处理计算结果，也提供了转换和组合 CompletableFuture 的方法。

　　没有用过的同学,我们先来一个入门使用了解一下

public class CompletableFutureAction {

    private static final Random RANDOM = new Random(System.currentTimeMillis());

    public static void main(String[] args) {

        //很少有这么使用的.

        CompletableFuture<Double> completableFuture = new CompletableFuture<>();

        new Thread(()->{

            double v = get();

            completableFuture.complete(v);

        }).start();

        System.out.println("程序执行");

        //当程序完成时自动回调,不需要阻塞

        completableFuture.whenComplete((v,t)->{

            Optional.ofNullable(v).ifPresent(System.out::println);

            Optional.ofNullable(t).ifPresent(x->{t.printStackTrace();});

        });

        System.out.println("程序执行后...");

    }

     static double get(){

        try {

            System.out.println("执行耗时任务");

            Thread.sleep(RANDOM.nextInt(10000));

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

        return RANDOM.nextDouble();

    }

}

CompletableFuture.supplyAsync

我们一般不使用new的方式创建completableFuture

在main 方法中我们在使用一个例子来介绍它的使用

因为在mian方法中,主线程可能会提前结束所以我们在做这个例子的时候,需要对线程做一些阻塞

public class CompletableFutureAction1 {

    public static void main(String[] args) throws InterruptedException {

　　　　//另一种方式来等到结果输出在结束

        ExecutorService executorService = Executors.newFixedThreadPool(2,r -> {

            Thread t = new Thread(r);

            //设置成守护线程->结果不一定能等到执行结束

            t.setDaemon(false);

            return t;

        });

        AtomicBoolean atomicBoolean = new AtomicBoolean(true);

        CompletableFuture.supplyAsync(CompletableFutureAction::get,executorService).whenComplete((v,t)->

        {

            Optional.of(v).ifPresent(System.out::println);

            atomicBoolean.set(false);

            executorService.shutdown();

            Optional.ofNullable(t).ifPresent(x->{t.printStackTrace();});

        });

        System.out.println("没有进入阻塞");

//        Thread.currentThread().join();

       /* while (atomicBoolean.get()){

        }*/

        executorService.execute(()-> System.out.println("2222"));

    }

}

我们可以使用这样的方式来判断获取到结果

  AtomicBoolean atomicBoolean = new AtomicBoolean(true);
        CompletableFuture.supplyAsync(CompletableFutureAction::get).whenComplete((v,t)->
        {
            Optional.of(v).ifPresent(System.out::println);
            atomicBoolean.set(false);
            executorService.shutdown();
            Optional.ofNullable(t).ifPresent(x->{t.printStackTrace();});
        });

        System.out.println("没有进入阻塞");
//        Thread.currentThread().join();
       while (atomicBoolean.get()){

        }

comletableFuture流水线的工作

 CompletableFuture.supplyAsync(CompletableFutureAction::get,executorService)

                .thenApply(CompletableFutureAction2::multiply).whenComplete((v,t)->{

            Optional.of(v).ifPresent(System.out::println);

//            executorService.shutdown();

            Optional.ofNullable(t).ifPresent(x->{t.printStackTrace();}  );

        });

  public static double multiply(double value){

        try {

            Thread.sleep(1000);

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

        return  value*10d;

    }

   static double get(){

        try {

            System.out.println("=======执行耗时任务");

            Thread.sleep(RANDOM.nextInt(10000));

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

         double v = RANDOM.nextDouble();

         System.out.println(v);

         return v;

    }

执行的结果:

=======执行耗时任务
没有进入阻塞
0.808110430680034
8.08110430680034

多任务调度方式模拟:

        List<Integer> ids = Arrays.asList(1, 2, 3, 4, 5);

        Stream<CompletableFuture<Double>> completableFutureStream = ids.parallelStream().map(i -> CompletableFuture.supplyAsync(() -> queryByid(i), executorService));

　　//这边也是并行执行       
 List<Double> collect = completableFutureStream.map(future -> future.thenApply(CompletableFutureAction2::multiply)).map(CompletableFuture::join).collect(Collectors.toList());

        System.out.println(collect);

public static double queryByid(double i){
    return  CompletableFutureAction.get();
}

巴特西

completable 用法

CompletableFuture

没有用过的同学,我们先来一个入门使用了解一下

CompletableFuture.supplyAsync

comletableFuture流水线的工作

comletableFuture API

最新文章

热门文章