一、CompletableFuture用法入门介绍

入门介绍的一个例子：

 package com.cy.java8;

 import java.util.Random;

 import java.util.concurrent.CompletableFuture;

 public class CompletableFutureInAction {

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

     public static void main(String[] args){

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

         new Thread(() -> {

             double value = get();

             completableFuture.complete(value);

         }).start();

         System.out.println("do other things...");

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

             System.out.println("complete. value = "+ t);

             if(e != null){

                 e.printStackTrace();

             }

         });

     }

     private static double get(){

         try {

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

         } catch (InterruptedException e) {

             e.printStackTrace();

         }

         return RANDOM.nextDouble();

     }

 }

console打印：

do other things...

complete. value = 0.8244376567363494

　

二、CompletableFuture.supplyAsync

CompletableFuture很少有直接new出来的方式去用的，一般都是通过提供的静态方法来使用。

1.使用CompletableFuture.supplyAsync来构造CompletableFuture：

 package com.cy.java8;

 import java.util.concurrent.*;

 import static com.cy.java8.CompletableFutureInAction.get;

 public class CompletableFutureInAction2 {

     public static void main(String[] args) {

         /**

          * 可以发现value=..没有被打印，为什么呢？

          * 因为此方法构造出来的线程是demon的，守护进程，main执行结束之后就消失了，所以

          * 根本没来得及执行whenComplete中的语句

          */

         CompletableFuture.supplyAsync(() -> get())

                 .whenComplete((v, e) -> {

                     System.out.println("value = " + v);

                     if (e != null) {

                         e.printStackTrace();

                     }

                 });

         System.out.println("do other things...");

     }

 }

2.要将上面whenComplete中的语句执行，进行改造：

 package com.cy.java8;

 import java.util.concurrent.*;

 import java.util.concurrent.atomic.AtomicBoolean;

 import static com.cy.java8.CompletableFutureInAction.get;

 public class CompletableFutureInAction2 {

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

         AtomicBoolean finished = new AtomicBoolean(false);

         CompletableFuture.supplyAsync(() -> get())

                 .whenComplete((v, e) -> {

                     System.out.println("value = " + v);

                     if (e != null) {

                         e.printStackTrace();

                     }

                     finished.set(true);

                 });

         System.out.println("do other things...");

         while(!finished.get()){

             Thread.sleep(1);

         }

     }

 }

改写之后， main线程发现如果finished没有变为true就会一直等1ms，直到whenComplete执行将finished变为true。

3.上面的改写很low，其实只要将守护线程变为前台进程，main结束后不会消失就行了。

 package com.cy.java8;

 import java.util.concurrent.*;

 import static com.cy.java8.CompletableFutureInAction.get;

 public class CompletableFutureInAction2 {

     public static void main(String[] args){

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

             Thread t = new Thread(r);

             t.setDaemon(false);     //非守护线程

             return t;

         });

         CompletableFuture.supplyAsync(() -> get(), executorService)

                 .whenComplete((v, e) -> {

                     System.out.println("value = " + v);

                     if (e != null) {

                         e.printStackTrace();

                     }

                 });

         System.out.println("do other things...");

         //main执行结束之后，executorService线程不会结束，需要手动shutdown

         executorService.shutdown();

     }

 }

三、thenApply：           　　　　

 package com.cy.java8;

 import java.util.concurrent.CompletableFuture;

 import java.util.concurrent.ExecutorService;

 import java.util.concurrent.Executors;

 public class CompletableFutureInAction3 {

     public static void main(String[] args) {

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

             Thread t = new Thread(r);

             t.setDaemon(false);

             return t;

         });

         /**

          * 将执行完的结果再*100

          */

         CompletableFuture.supplyAsync(CompletableFutureInAction::get, executor)

                             .thenApply(v -> multiply(v))

                             .whenComplete((v, e) -> System.out.println(v));

     }

     private static double multiply(double value){

         try {

             Thread.sleep(1000);

         } catch (InterruptedException e) {

             e.printStackTrace();

         }

         return value * 100;

     }

 }

console打印：

43.15351824222534

四、CompletableFuture.join()　　

 package com.cy.java8;

 import java.util.Arrays;

 import java.util.List;

 import java.util.concurrent.CompletableFuture;

 import java.util.concurrent.ExecutorService;

 import java.util.concurrent.Executors;

 import java.util.stream.Collectors;

 public class CompletableFutureInAction3 {

     public static void main(String[] args) {

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

             Thread t = new Thread(r);

             t.setDaemon(false);

             return t;

         });

         /**

          * 需求：将一组商品列表里面的每个商品对应的价格查询出来，并将这个价格*100.

          * 5个商品同时并发去做这件事

          *

          * CompletableFuture.join():等到所有的结果都执行结束，会返回CompletableFuture自己本身

          * 执行完的结果，等于get()返回的结果。

          */

         List<Integer> productionIDs = Arrays.asList(1, 2, 3, 4, 5);     //待查的一组商品列表的ID

         List<Double> priceList = productionIDs.stream().map(id -> CompletableFuture.supplyAsync(() -> queryProduction(id), executor))

                                                         .map(future -> future.thenApply(price -> multiply(price)))

                                                         .map(multiplyFuture -> multiplyFuture.join())

                                                         .collect(Collectors.toList());

         System.out.println(priceList);

         /**

          * 按照以前，要5个分别for循环去查询

          * 或者分多个线程去查询，再将每个线程查询的结果汇总，等到全部线程都执行完了，结果也就出来了

          */

     }

     private static double multiply(double value) {

         try {

             Thread.sleep(1000);

         } catch (InterruptedException e) {

             e.printStackTrace();

         }

         return value * 100;

     }

     /**

      * 模拟 根据商品id查询对应的价格

      * @param id

      * @return

      */

     private static double queryProduction(int id){

         return CompletableFutureInAction.get();

     }

 }

console打印：

[90.93730009374265, 23.65282935900653, 17.415066430776815, 16.605197824452343, 60.143109082288206]

说明：这里多个任务同时执行，最终把结果汇总到一起 ，这种都是并行去执行的，编写代码也比较简洁，不需要考虑多线程之间的一些交互、锁、多线程之间的通信、控制，都不需要去关心。

五、CompletableFuture的常用API介绍　

supplyAsync
thenApply
whenComplete
handle
thenRun
thenAccept
thenCompose
thenCombine
thenAcceptBoth

runAfterBoth
applyToEither
acceptEither
runAfterEither
anyOf
allOf

1）supplyAsync、thenApply、whenComplete前面的代码已经介绍了。

 package com.cy.java8;

 import java.util.concurrent.CompletableFuture;

 public class CompletableFutureInAction4 {

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

         CompletableFuture.supplyAsync(() -> 1)

                 .thenApply(v -> Integer.sum(v,10))

                 .whenComplete((v, e) -> System.out.println(v));

         Thread.sleep(1000);

     }

 }

2）whenCompleteAsync:    whenComplete是同步的方式，如果对于结果的处理是比较占时间的，不想通过这种同步的方式去做，可以用whenCompleteAsync进行异步操作。

3）handle：和thenApply差不多，只是多了一个对于异常的考虑。

 package com.cy.java8;

 import java.util.concurrent.CompletableFuture;

 public class CompletableFutureInAction4 {

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

         CompletableFuture.supplyAsync(() -> 1)

                 .handle((v, e) -> Integer.sum(v, 10))

                 .whenComplete((v, e) -> System.out.println(v));

         Thread.sleep(1000);

     }

 }

4）thenRun：如果想在completableFuture整个执行结束之后，还想进行一个操作，可以thenRun(Runnable r)

 package com.cy.java8;

 import java.util.concurrent.CompletableFuture;

 public class CompletableFutureInAction4 {

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

         CompletableFuture.supplyAsync(() -> 1)

                 .handle((v, e) -> Integer.sum(v, 10))

                 .whenComplete((v, e) -> System.out.println(v))

                 .thenRun(()-> System.out.println("thenRunning..."));

         Thread.sleep(1000);

     }

 }
11

thenRunning...

5）thenAccept:   thenAccept(Consumer c)里面传的是consumer，对执行结果进行消费，不会对执行结果进行任何操作。　　

 package com.cy.java8;

 import java.util.concurrent.CompletableFuture;

 public class CompletableFutureInAction4 {

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

         CompletableFuture.supplyAsync(() -> 1)

                         .thenApply(v -> Integer.sum(v, 10))

                         .thenAccept(System.out::println);

         Thread.sleep(1000);

     }

 }
11

6）thenCompose： 对执行结果再交给另外一个CompletableFuture，它再去对这个执行结果进行另外的计算。compose：组合，组合设计模式。

 package com.cy.java8;

 import java.util.concurrent.CompletableFuture;

 public class CompletableFutureInAction4 {

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

         CompletableFuture.supplyAsync(() -> 1)

                         .thenCompose(v -> CompletableFuture.supplyAsync(() -> v * 10))

                         .thenAccept(System.out::println);

         Thread.sleep(1000);

     }

 }
10

7）thenCombine： thenCombine(CompletableFuture extends CompletionStage, BiFuntion)

　　　　　　　　  CompletableFuture的计算结果v1作为BiFunction的第1个入参，thenCombine中的第一个参数CompletableFuture的计算结果v2作为BiFunction的第2个入参，biFunction进行操作然后返回结果。

 package com.cy.java8;

 import java.util.concurrent.CompletableFuture;

 public class CompletableFutureInAction4 {

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

         CompletableFuture.supplyAsync(() -> 1)

                         .thenCombine(CompletableFuture.supplyAsync(() -> 2.0), (v1, v2) -> v1 + v2)

                         .thenAccept(System.out::println);

         Thread.sleep(1000);

     }

 }
3.0

8）thenAcceptBoth： 和thenCombine差不多，只不过它的第二个参数是BiConsumer　

 package com.cy.java8;

 import java.util.concurrent.CompletableFuture;

 public class CompletableFutureInAction4 {

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

         CompletableFuture.supplyAsync(() -> 1)

                         .thenAcceptBoth(CompletableFuture.supplyAsync(() -> 2.0), (v1, v2) -> {

                             System.out.println("value=" + (v1 + v2));

                         });

         Thread.sleep(1000);

     }

 }
value=3.0

9）runAfterBoth：两个CompletableFuture都执行结束之后，run

 package com.cy.java8;

 import java.util.concurrent.CompletableFuture;

 public class CompletableFutureInAction5 {

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

         CompletableFuture.supplyAsync(() -> {

             System.out.println(Thread.currentThread().getName() + " is running");

             return 1;

         }).runAfterBoth(CompletableFuture.supplyAsync(() -> {

             System.out.println(Thread.currentThread().getName() + " is running too");

             return 2;

         }), () -> System.out.println("both done"));

         Thread.sleep(1000);

     }

 }
ForkJoinPool.commonPool-worker-9 is running

ForkJoinPool.commonPool-worker-9 is running too

both done

　　

10）applyToEither

applyToEither：两个CompletableFuture只要有1个执行完了，就将这个CompletableFuture交给Function。谁先执行完就将谁交给Function去执行　　

 package com.cy.java8;

 import java.util.concurrent.CompletableFuture;

 public class CompletableFutureInAction5 {

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

         CompletableFuture.supplyAsync(() -> {

             try {

                 Thread.sleep(900);

             } catch (InterruptedException e) {

                 e.printStackTrace();

             }

             System.out.println("I am future 1");

             return 1;

         }).applyToEither(CompletableFuture.supplyAsync(() -> {

             try {

                 Thread.sleep(50);

             } catch (InterruptedException e) {

                 e.printStackTrace();

             }

             System.out.println("I am future 2");

             return 2;

         }), v -> {

             System.out.println("value = " + v);

             return v * 10;

         }).thenAccept(System.out::println);

         Thread.currentThread().join();

     }

 }
I am future 2

value = 2

20

I am future 1

　　

11）acceptEither

acceptEither：acceptEither(CompletableFuture extends CompletionStage, Consumer), 两个CompletableFuture谁先执行完成，就将谁的结果交给consumer执行。

 package com.cy.java8;

 import java.util.concurrent.CompletableFuture;

 public class CompletableFutureInAction5 {

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

         CompletableFuture.supplyAsync(() -> {

             try {

                 Thread.sleep(900);

             } catch (InterruptedException e) {

                 e.printStackTrace();

             }

             System.out.println("I am future 1");

             return 1;

         }).acceptEither(CompletableFuture.supplyAsync(() -> {

             try {

                 Thread.sleep(50);

             } catch (InterruptedException e) {

                 e.printStackTrace();

             }

             System.out.println("I am future 2");

             return 2;

         }), v -> System.out.println("value = " + v));

         Thread.currentThread().join();

     }

 }
I am future 2

value = 2

I am future 1

　　

12）runAfterEither　

runAfterEither: runAfterEither(CompletionStage, Runnable),只要有一个CompletableFuture执行完了，就执行run

 package com.cy.java8;

 import java.util.concurrent.CompletableFuture;

 public class CompletableFutureInAction5 {

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

         CompletableFuture.supplyAsync(() -> {

             try {

                 Thread.sleep(900);

             } catch (InterruptedException e) {

                 e.printStackTrace();

             }

             System.out.println("I am future 1");

             return 1;

         }).runAfterEither(CompletableFuture.supplyAsync(() -> {

             try {

                 Thread.sleep(50);

             } catch (InterruptedException e) {

                 e.printStackTrace();

             }

             System.out.println("I am future 2");

             return 2;

         }), () -> System.out.println("done."));

         Thread.currentThread().join();

     }

 }
I am future 2

done.

I am future 1

　　

13）allOf

allOf(CompletableFuture<?>... cfs)，返回值是CompletableFuture<Void>。要等所有的CompletableFuture都执行完成，才能执行下一步动作。

 package com.cy.java8;

 import java.util.Arrays;

 import java.util.List;

 import java.util.Random;

 import java.util.concurrent.CompletableFuture;

 import java.util.stream.Collectors;

 public class CompletableFutureInAction5 {

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

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

         List<CompletableFuture<Double>> list = Arrays.asList(1, 2, 3, 4).stream()

                 .map(i -> CompletableFuture.supplyAsync(CompletableFutureInAction5::get))

                 .collect(Collectors.toList());

         //要等所有的CompletableFuture这些task执行完了，才会打印done.

         CompletableFuture.allOf(list.toArray(new CompletableFuture[list.size()]))

                 .thenRun(() -> System.out.println("done."));

         Thread.currentThread().join();

     }

     static double get() {

         try {

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

         } catch (InterruptedException e) {

             e.printStackTrace();

         }

         double result = RANDOM.nextDouble();

         System.out.println(result);

         return result;

     }

 }
0.6446554001163166

0.24435437709196395

0.18251850071600362

0.5261702037394511

done.

　　

14）anyOf

和allOf相反，只要有一个CompletableFuture执行完成，就会执行下一步动作

 package com.cy.java8;

 import java.util.Arrays;

 import java.util.List;

 import java.util.Random;

 import java.util.concurrent.CompletableFuture;

 import java.util.stream.Collectors;

 public class CompletableFutureInAction5 {

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

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

         List<CompletableFuture<Double>> list = Arrays.asList(1, 2, 3, 4).stream()

                 .map(i -> CompletableFuture.supplyAsync(CompletableFutureInAction5::get))

                 .collect(Collectors.toList());

         //只要有一个CompletableFuture执行完了，就会打印done.

         CompletableFuture.anyOf(list.toArray(new CompletableFuture[list.size()]))

                 .thenRun(() -> System.out.println("done."));

         Thread.currentThread().join();

     }

     static double get() {

         try {

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

         } catch (InterruptedException e) {

             e.printStackTrace();

         }

         double result = RANDOM.nextDouble();

         System.out.println(result);

         return result;

     }

 }
0.1334361442807943

done.

0.6715112881360222

0.12945359790698785

0.1307762755130788

　　

----

CompletableFuture用法介绍的更多相关文章

  1. 好压（HaoZip）的命令行模式用法介绍

    好压压缩软件,又叫“2345好压”,是一款国产的优秀压缩软件,目前是免费的,据官网介绍,该软件永久免费.官网地址:http://haozip.2345.com/ 本文主要对该软件的命令行模式用法进行介 ...

  2. sql事务（Transaction）用法介绍及回滚实例

    sql事务(Transaction)用法介绍及回滚实例 事务(Transaction)是并发控制的单位,是用户定义的一个操作序列.这些操作要么都做,要么都不做,是一个不可分割的工作单位.通过事务, S ...

  3. STL vector用法介绍

    STL vector用法介绍 介绍 这篇文章的目的是为了介绍std::vector,如何恰当地使用它们的成员函数等操作.本文中还讨论了条件函数和函数指针在迭代算法中使用,如在remove_if()和f ...

  4. 怎么通过activity里面的一个按钮跳转到另一个fragment（android FragmentTransaction.replace的用法介绍）

    即:android FragmentTransaction.replace的用法介绍 Fragment的生命周期和它的宿主Activity密切相关,几乎和宿主Activity的生命周期一致,他们之间最 ...

  5. Oracle CASE WHEN 用法介绍[Z]

    Oracle CASE WHEN 用法介绍 1. CASE WHEN 表达式有两种形式 --简单Case函数 CASE sex WHEN '1' THEN '男' WHEN '2' THEN '女' ...

  6. LinqToXml高级用法介绍

    LinqToXml高级用法介绍 一.函数构造 什么是函数构造?其是指通过单个语句构建XML树的能力. 那么它有什么作用呢? 作用1.用单个表达式快速创建复杂的XML树 见实例代码CreateXml( ...

  7. Oracle学习笔记_06_CASE WHEN 用法介绍

    1. CASE WHEN 表达式有两种形式 --简单Case函数 CASE sex ' THEN '男' ' THEN '女' ELSE '其他' END --Case搜索函数 CASE ' THEN ...

  8. mysql进阶(六)模糊查询的四种用法介绍

    mysql中模糊查询的四种用法介绍 这篇文章主要介绍了mysql中模糊查询的四种用法,需要的朋友可以参考下. 下面介绍mysql中模糊查询的四种用法: 1 %: 表示任意0个或多个字符.可匹配任意类型 ...

  9. object-fit 属性的用法介绍

    这个要在宽,高都是100%的情况下才能提现 object-fit 属性的用法介绍 fill(不保持纵横比缩放图片,使图片完全适应) contain(保持纵横比缩放图片,使图片的长边能完全显示出来) c ...

随机推荐

  1. Systemctl和service、chkconfig命令的关系

      systemctl命令:是一个systemd工具,主要负责控制systemd系统和服务管理器. service命令:可以启动.停止.重新启动和关闭系统服务,还可以显示所有系统服务的当前状态. ch ...

  2. 【CF 482E】ELCA

    题意 题解 50pts 由于这题 \(2s\),所以可以信仰一波,暴力修改.查询. 暴力修改的复杂度是 \(O(n)\),暴力查询的复杂度是 \(O(n^2)\). 但不难发现可以通过记录子树大小来优 ...

  3. Linux下Mongodb的安装

    [root@localhost usr]# cd /usr //创建Mongodb目录 用于存放Mongodb的程序 [root@localhost usr]# mkdir mongodb [root ...

  4. centos7时区同步（时间24小时格式显示）

    我们在服务器安装linux系统时,有时会因服务器时间或者时区不正确导致程序出现错误. 首先输入date命令查看当前的时间和时区.要注意CST   EDT 等时区的区别 介绍一种与时间服务器上时间同步的 ...

  5. react 引入swiper

    npm install --save swiper 应用模块引入 import 'swiper/dist/css/swiper.min.css' import Swiper from 'swiper'

  6. react 中的路由 属性exact

    https://www.cnblogs.com/nailc/p/8718137.html(copy)

  7. TTTTTTTTTTT hdu 1520 Anniversary party 生日party 树形dp第一题

    Anniversary party Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others ...

  8. HGOI20190813 省常中互测6

    Problem A 蛋糕 将$n \times m $大小的蛋糕切成每块为$1 \times 1$大小的$n\times m$块. 交换任意两块蛋糕的切割顺序的方案算作一种. 对于$100 \%$的数 ...

  9. 配置zookeeper开机自启动

    第一种.修改vim /etc/rc.local文件 vim /etc/rc.local 加入: export JAVA_HOME=/usr/local/JAVA/ --JDK安装路径/data/zoo ...

  10. 使用宝塔面板 配置nginx 访问ftp服务器下面的图片

    如果 你在服务器上 运行war项目 可以在tomcat 配置访问的: tomcat 也贴出来吧! 一.tomca配置访问,需要更改配置文件server.xml ,如果找不到,自己好好找一下  一般在 ...