1.同步API

1.1.阻塞式调用

1.2.调用了某个方法  
  
  
  
  
  ，调用方在被调用方执行的过程中会等待 
  
  
  
  
  
，被调用方执行结束返回


 


 


 


 


 

，调用方取得被调用方的返回值并继续运行

2.异步API

2.1.非阻塞式调用

2.2.会直接返回 
 
 
 
 
 ，或者至少在被调用方计算完成之前  
   
   
   
   
   
，将它剩余的计算任务交由另一个线程去做

2.2.1.该线程和调用方是异步的

2.3.返回的方式

2.3.1.通过回调函数

2.3.2.由调用方再次执行一个“等待

 

 

 

 

 
，直到计算完成           ”的方法调用

2.4.执行比较耗时的操作时
 

 

 

 

 

 ，尤其是那些依赖一个或多个远程服务的操作           ，使用异步任务可以改善程序的性能
 

 
 

 
 

 
 

 
 

 
 
，加快程序的响应速度

3.Future接口

3.1.对将来某个时刻会发生的结果进行建模

3.1.1.对异步计算进行建模










，返回一个指向执行结果的引用

3.1.2.运算结束后                 ，调用方可以通过该引用访问执行的结果

3.2.要使用Future
 
 
 
 
 
 
 
 
 
 
 
，通常你只需要将耗时的操作封装在一个Callable对象中















，再将它提交给ExecutorService

3.2.1.比更底层的Thread更好用

3.3.重载版本的get方法

3.3.1.接受一个超时的参数            ，定义线程等待Future结果的最长时间

3.3.2.尽量在代码中添加超时判断的逻辑

3.3.3.能防止程序永久地等待下去
 
  
 
  
 
  
 
  
 
  
 
，超时发生时










，程序会得到通知发生了TimeoutException

3.4.局限性

3.4.1.将两个异步计算合并为一个

3.4.1.1.两个异步计算之间相互独立 3.4.1.2.第二个又依赖于第一个的结果

3.4.2.等待Future集合中的所有任务都完成

3.4.3.仅等待Future集合中最快结束的任务完成（有可能因为它们试图通过不同的方式计算同一个值）  
  
  
  
  
  ，并返回它的结果

3.4.4.应对Future的完成事件（即当Future的完成事件发生时会收到通知 
  
  
  
  
  
，并能使用Future计算的结果进行下一步的操作


 


 


 


 


 

，不只是简单地阻塞等待操作的结果）

4.CompletableFuture类

4.1.实现了Future接口

4.2.使用了Lambda表达式以及流水线的思想

4.3.同步API的调用封装到一个CompletableFuture中 
 
 
 
 
 ，你能够以异步的方式使用其结果

4.4.涉及等待I/O的操作（包括网络连接等待）

4.5.依据等待/计算  
   
   
   
   
   
，或者W/C的比率设定需要使用的线程数

4.6.处理流的流水线中如果发生I/O等待

 

 

 

 

 
，流的延迟特性会让我们很难判断到底什么时候触发了等待

4.7.通过自定义CompletableFuture调度任务执行的执行器能够更充分地利用CPU资源

4.7.1.允许你对执行器（Executor）进行配置

4.7.1.1.尤其是线程池的大小
 

 

 

 

 

 ，让它以更适合应用需求的方式进行配置           ，满足程序的要求

4.7.2.调整线程池的大小
 

 
 

 
 

 
 

 
 

 
 
，能帮助你确保整体的计算不会因为线程都在等待I/O而发生阻塞

4.7.2.1.并行流API无法提供的

4.7.3.处理需大量使用异步操作的情况时










，这几乎是最有效的策略

4.8.supplyAsync方法

4.8.1.接受一个生产者（Supplier）作为参数                 ，返回一个CompletableFuture对象
 
 
 
 
 
 
 
 
 
 
 
，该对象完成异步执行后会读取调用生产者方法的返回值

4.8.2.传递第二个参数指定不同的执行线程执行生产者方法

4.9.thenCompose

4.9.1.允许你对两个异步操作进行流水线















，第一个操作完成时            ，将其结果作为参数传递给第二个操作

4.9.2.不带Async的方法和它的前一个任务一样
 
  
 
  
 
  
 
  
 
  
 
，在同一个线程中运行

4.9.3.更高效一点










，因为它少了很多线程切换的开销

4.10.thenComposeAsync

4.10.1.以Async结尾的方法会将后续任务提交到一个线程

4.11.thenCombine

4.11.1.接受名为BiFunction的第二个参数  
  
  
  
  
  ，这个参数定义了当两个CompletableFuture对象完成计算后 
  
  
  
  
  
，结果如何合并

4.12.thenCombineAsync

4.13.thenAccept

4.13.1.接受CompletableFuture执行完毕后的返回值做参数

4.13.2.一旦CompletableFuture计算得到结果


 


 


 


 


 

，它就返回一个CompletableFuture‹Void›

4.14.thenAcceptAsync

4.15.allOf

4.15.1.接受一个由CompletableFuture构成的数组 
 
 
 
 
 ，数组中的所有CompletableFuture对象执行完成之后  
   
   
   
   
   
，它返回一个CompletableFuture‹Void›对象

4.16.anyOf

4.16.1.接受一个CompletableFuture对象构成的数组

 

 

 

 

 
，返回由第一个执行完毕的CompletableFuture对象的返回值构成的CompletableFuture‹Object›

4.17.orTimeout

4.17.1.Java 9

4.17.2.在指定的超时到达时
 

 

 

 

 

 ，会通过Scheduled-ThreadExecutor线程结束该CompletableFuture对象           ，并抛出一个TimeoutException异常
 

 
 

 
 

 
 

 
 

 
 
，它的返回值是一个新的CompletableFuture对象

4.18.completeOnTimeOut

4.18.1.Java 9

4.18.2.如果服务偶然性地无法及时响应










，临时使用默认值继续执行也是一种可接受的解决方案

4.18.3.可以使用预定义的默认值继续执行                 ，不会发生失效

4.19.对异步超时机制的支持

4.20.completeExceptionally方法

4.20.1.将导致CompletableFuture内发生问题的异常抛出

4.20.2.提供了异常管理的机制
 
 
 
 
 
 
 
 
 
 
 
，让你有机会抛出/管理异步任务执行中发生的异常

5.Stream接口

5.1.计算密集型的操作















，并且没有I/O

5.2.底层依赖的是线程数量固定的通用线程池

5.3.实现简单            ，同时效率也可能是最高的

5.3.1.如果所有的线程都是计算密集型的
 
  
 
  
 
  
 
  
 
  
 
，那就没有必要创建比处理器核数更多的线程

6.线程池大小与处理器的利用率之比

6.1.Nthreads=NCPU＊UCPU＊(1+W/C)

6.2.NCPU是处理器的核的数目

6.2.1.通过Runtime.getRuntime().available Processors()得到

6.3.UCPU是期望的CPU利用率

6.3.1.该值应该介于0和1之间

6.4.W/C是等待时间与计算时间的比率