1.同步API与异步API

  • 同步API其实只是对传统方法调用的另一种称呼：你调用了某个方法，调用方在被调用方运行的过程中会等待，被调用方运行结束返回，调用方取得被调用方的返回值并继续运行。即使调用方和被调用方在同的线程中运行，调用方还是需要等待被调用方结束运行，这就是阻塞式调用这个名词的由来。
  • 与此相反，异步API会直接返回，或者至少在被调用方计算完成之前，将它剩余的计算任务交给另一个线程去做，该线程和调用方是异步的——这就是非阻塞式调用的由来。执行剩余计算任务的线程会将它的计算结果返回给调用方。返回的方式要么是通过回调函数，要么是由调用方再次执行一个“等待，直到计算完成”的方法调用。这种方式的计算在I/O系统程序设计中非常常见：你发起了一次磁盘访问，这次访问和你的其他计算操作是异步的，你完成其他的任务时，磁盘块的数据可能还没载入到内存，你只需要等待数据的载入完成。

2.Future 接口的局限性

  • 虽然 Future 以及相关使用方法提供了异步执行任务的能力，但是对于结果的获取却是很不方便，只能通过阻塞或者轮询的方式得到任务的结果。
    阻塞的方式显然和我们的异步编程的初衷相违背，轮询的方式又会耗费无谓的 CPU 资源，而且也不能及时地得到计算结果。
  • 它很难直接表述多个Future 结果之间的依赖性。实际开发中，我们经常需要达成以下目的：
    (1) 将多个异步计算的结果合并成一个
    (2) 等待Future集合中的所有任务都完成
    (3) Future完成事件（即任务完成以后触发执行动作）
    (4)…

3.CompletionStage

CompletionStage代表异步计算过程中的某一个阶段，一个阶段完成以后可能会触发另外一个阶段。

一个阶段的计算执行可以是一个Function，Consumer或者Runnable。比如：stage.thenApply(x -> square(x)).thenAccept(x -> System.out.print(x)).thenRun(() -> System.out.println())

一个阶段的执行可能是被单个阶段的完成触发，也可能是由多个阶段一起触发

4.CompletableFuture

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

它可能代表一个明确完成的Future，也有可能代表一个完成阶段（ CompletionStage ），它支持在计算完成以后触发一些函数或执行某些动作。

它实现了Future和CompletionStage接口

4.1 supplyAsync

public class CompletableFutureInAction {
    public static void main(String[] args){
        CompletableFuture.supplyAsync(CompletableFutureInAction::get)
                .whenComplete((v, t) -> {
                    Optional.ofN(v).ifPresent(System.out::println);
                    Optional.of(t).ifPresent(x -> x.printStackTrace());
                });
        System.out.println("====i am no ---block----");
    }
	
	static double get() {
        try {
            Thread.sleep(RANDOM.nextInt(10000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        double result = RANDOM.nextDouble();
        System.out.println(result);
        return result;
    }
}

//执行结果发现：
  (1)主线程会立即输出====i am no ---block----，而不是先等待异步任务执行完再输出
  (2)异步任务会未执行，整个程序都退出了（这是因为supplyAsync工厂方法，使用的线程池里的线程默认是守护线程）
  

public class CompletableFutureInAction {

    public static void main(String[] args)
            throws InterruptedException {
        AtomicBoolean finished = new AtomicBoolean(false);
        ExecutorService executor = Executors.newFixedThreadPool(2, r -> {
            Thread t = new Thread(r);
            t.setDaemon(false);
            return t;
        });

        CompletableFuture.supplyAsync(CompletableFutureInAction::get, executor)
                .whenComplete((v, t) -> {
                    Optional.of(v).ifPresent(System.out::println);
                    finished.set(true);
                });

        System.out.println("====i am no ---block----");

    static double get() {
        try {
            Thread.sleep(RANDOM.nextInt(10000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        double result = RANDOM.nextDouble();
        System.out.println(result);
        return result;
    }
}

//执行结果发现：
  (1)主线程会立即输出====i am no ---block----，而不是先等待异步任务执行完再输出
  (2)异步任务会执行，并打印
  (3)主线程未退出，这是因为executor里的线程是非守护的，线程执行完后，executor还是存在的，
     需要调用executor.shutdown()，主线程才能退出

4.2 join

CompletableFuture类中的join方法和Future接口中的get有相同的含义，并且也声明在Future接口中，它们唯一的不同是join不会抛出任何检测到的异常。

public List<String> findPrices(String product) { 
	 List<CompletableFuture<String>> priceFutures = 
		 shops.stream() 
		 .map(shop -> CompletableFuture.supplyAsync( 
						 () -> shop.getName() + " price is " +
						 shop.getPrice(product))) 
		 .collect(Collectors.toList()); 
		 
	 return priceFutures.stream() 
			 .map(CompletableFuture::join) 
			 .collect(toList()); 
}

注意到了吗？这里使用了两个不同的Stream流水线，而不是在同一个处理流的流水线上一个接一个地放置两个map操作——这其实是有缘由的。考虑流操作之间的延迟特性，如果你在单一流水线中处理流，发向不同商家的请求只能以同步、顺序执行的方式才会成功。
在这里插入图片描述

  • 上半部分展示了使用单一流水线处理流的过程，我们看到，执行的流程（以虚线标识）是顺序的。事实上，新的CompletableFuture对象只有在前一个操作完全结束之后，才能创建。
  • 与此相反，图的下半部分展示了如何先将CompletableFutures对象聚集到一个列表中（即图中以椭圆表示的部分），让对象们可以在等待其他对象完成操作之前就能启动。

4.3 thenApply、handle、whenComplete

public static void main(String[] args) {
    CompletableFuture.supplyAsync(() -> 1)
            .thenApply(i -> Integer.sum(i, 10))
            .whenComplete((v, t) -> System.out.println(v));
}
//输出：11
//whenCompleteAsync：会开启一个异步任务执行

CompletableFuture.supplyAsync(() -> 1)
       .handle((v, t) -> Integer.sum(v, 10))
       .whenComplete((v, t) -> System.out.println(v))
//输出：11
//handle相对于thenApply，多了个异步考虑t

4.4 thenRun、thenAccept

CompletableFuture.supplyAsync(() -> 1)
       .handle((v, t) -> Integer.sum(v, 10))
       .whenComplete((v, t) -> System.out.println(v))
       .thenRun(System.out::println);
//输出：11
           --这里有这个空格
//handle相对于thenApply，多了个异步考虑t
//thenRun(Runnable action)会执行一个没有入参数的命令，可能有返回值       


CompletableFuture.supplyAsync(() -> 1)
                .thenApply(i -> Integer.sum(i, 10))
                .thenAccept(System.out::println);
//输出：11
//thenAccept(Consumer<? super T> action) 执行consumer，没有返回值

4.5 thenCombine、thenAcceptBoth

CompletableFuture.supplyAsync(() -> 1)
                .thenCompose(i -> CompletableFuture.supplyAsync(() -> 10 * i))
                .thenAccept(System.out::println);
//输出：10
//thenCompose：接收前一个任务执行结果作为参数
                
CompletableFuture.supplyAsync(() -> 1)
                .thenCombine(CompletableFuture.supplyAsync(() -> 2.0d), (r1, r2) -> r1 + r2)
                .thenAccept(System.out::println);
//输出：3.0
//thenCombine：第一个参数：新的异步任务，第二个参数：<前一个任务执行的结果, 当前启动的新的异步任务的执行结果>

CompletableFuture.supplyAsync(() -> 1)
                .thenAcceptBoth(CompletableFuture.supplyAsync(() -> 2.0d), (r1, r2) -> {
                    System.out.println(r1);
                    System.out.println(r2);
                    System.out.println(r1 + r2);
                });
//输出：1
//	   2.0
//	   3.0
//thenAcceptBoth相对于thenCombine的区别是第二个参数是一个consumer

4.6 runAfterBoth、applyToEither、acceptEither、runAfterEither

public static void main(String[] args) {
        CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread().getName() + " is running.");
            return 1;
        }).runAfterBoth(CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread().getName() + " is running.");
            return 2;
        }), () -> System.out.println("done"));

    }
//输出：ForkJoinPool.commonPool-worker-5 is running.
//		ForkJoinPool.commonPool-worker-3 is running.
//		done
//runAfterBoth：二个异步任务都执行完成后，在执行其第二个参数的内容
    
CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread().getName() + " is running.");
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return 1;
        }).runAfterBoth(CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread().getName() + " is running.");
            return 2;
        }), () -> System.out.println("done"));
//输出：ForkJoinPool.commonPool-worker-5 is running.
//		ForkJoinPool.commonPool-worker-3 is running.
//注意：main线程执行完后，因为异步任务都是守护线程，所以会自动退出，导致未执行完，所以未打印出done 


CompletableFuture.supplyAsync(() -> {
            System.out.println("I am future 1");
            return CompletableFutureInAction .get();
        }).applyToEither(CompletableFuture.supplyAsync(() -> {
            System.out.println("I am future 2");
            return CompletableFutureInAction .get();
        }), v -> v * 10)
                .thenAccept(System.out::println);     
//输出:I am future 2
//	   I am future 1
//	   3.414705885166589
//只要有一个任务执行完，就可以利用这个任务执行结果，继续做后面的事情了

CompletableFuture.supplyAsync(() -> {
            System.out.println("I am future 1");
            return CompletableFutureInAction.get();
        }).acceptEither(CompletableFuture.supplyAsync(() -> {
            System.out.println("I am future 2");
            return CompletableFutureInAction.get();
        }), v -> System.out.println(v * 10));
//输出:I am future 2
//	   I am future 1
//	   3.414705885166589
//acceptEither相对于applyToEither，第二个参数是一个consumer


//CompletableFuture<Void> acceptEither(CompletableFuture<? extends T> other, Consumer<? super T> block)
//CompletableFuture<Void> runAfterEither(CompletableFuture<?> other, Runnable action)

4.7 allOf、anyOf

List<CompletableFuture<Double>> collect = Arrays.asList(1, 2, 3, 4)
                .stream()
                .map(i -> CompletableFuture.supplyAsync(CompletableFutureInAction::get))
                .collect(toList());

        CompletableFuture.allOf(collect.toArray(new CompletableFuture[collect.size()]))
                .thenRun(() -> System.out.println("done")
//输出： 0.12233445
//       0.18233745   
//       0.22255445   
//       0.32238445   
//       done  
//allOf：所有CompletableFuture执行完后，才可以执行下一步操作     

List<CompletableFuture<Double>> collect = Arrays.asList(1, 2, 3, 4)
                .stream()
                .map(i -> CompletableFuture.supplyAsync(CompletableFutureInAction::get))
                .collect(toList());

        CompletableFuture.anyOf(collect.toArray(new CompletableFuture[collect.size()]))
                .thenRun(() -> System.out.println("done")
//输出： 0.12233445
//       done  
//anyOf：只要有一个CompletableFuture执行完后，就可以执行下一步操作
Logo
CSDN学习社区

CSDN联合极客时间，共同打造面向开发者的精品内容学习社区，助力成长！

更多推荐

嵌入式作业（七）：基于Ardunio的STM32串口通信

嵌入式作业（七）0作业要求1Ardunio 完成STM32的串口通信（1）安装Ardunio IDE（2）stm32串口通信2关于 stduino IDE0作业要求安装 Ardunio IDE 和相关软件支持库，在Ardunio 完成STM32板子的串口通信程序：（1）持续向串口输出“Hello world！”；（2）当接收到“stop!”时，停止输出。网上有一个国人版的MCU集成开发平台， st

avatar CSDN学习社区

JDBC详解

JDBC文章目录JDBC什么是JDBC?JDBC驱动程序:Java使用JDBC访问数据库的步骤:设置classpath:Oracle连接字符串的书写格式:简单的例子:常用数据库的驱动程序及JDBC URL:Oracle数据库:SQL Server数据库MySQL数据库Access数据库PreparedStatement接口:JNDI-数据源（Data Source）与连接池（Connection

avatar CSDN学习社区

“模式识别与机器学习”学习笔记no2.再谈感知机

接**上篇：上篇主要进行了PLA，Pocket算法的理论过程分析和在给定数据集上利用pocket算法对数据集进行分类学习，得到错分数量最少的分类面。上篇中pocket算法的过程已经进行了编程和测试，框架已经建立了起来，这一篇主要上篇中没有提到或涉及不深的几个问题。1.数据集的构造。上篇是直接使用了题目给的向量，这次来根据正态分布来产生数据集。np.random.normal函数可以根据均值和方差生

avatar CSDN学习社区