2019独角兽企业重金招聘Python工程师标准>>> 
同步阻塞调用
即串行调用，响应时间为所有服务的响应时间总和；
public class Test {
public static void main(String[] args) throws Exception {
RpcService rpcService = new RpcService();
HttpService httpService = new HttpService();
//耗时10ms
Map result1 = rpcService.getRpcResult();
//耗时20ms
Integer result2 = httpService.getHttpResult();
//总耗时30ms
}
static class RpcService {
Map getRpcResult() throws Exception {
//调用远程方法（远程方法耗时约10ms，可以使用Thread.sleep模拟）
Thread.sleep(10);
return null;
}
}
static class HttpService {
Integer getHttpResult() throws Exception {
//调用远程方法（远程方法耗时约20ms，可以使用Thread.sleep模拟）
Thread.sleep(20);
return 0;
}
}
}
半异步(异步Future)
线程池，异步Future，使用场景：并发请求多服务，总耗时为最长响应时间；提升总响应时间，但是阻塞主请求线程，高并发时依然会造成线程数过多，CPU上下文切换；
简单说一下 Future模式，Future模式可以这样来描述：我有一个任务，提交给了Future，Future替我完成这个任务。期间我自己可以去做任何想做的事情。一段时间之后，我就便可以从Future那儿取出结果。
public interface Future {
boolean cancel(boolean mayInterruptIfRunning);
boolean isCancelled();
boolean isDone();
V get() throws InterruptedException, ExecutionException;
V get(long timeout, TimeUnit unit)
throws InterruptedException, ExecutionException, TimeoutException;
}
public class Test {
final static ExecutorService executor = Executors.newFixedThreadPool(2);
public static void main(String[] args) {
RpcService rpcService = new RpcService();
HttpService httpService = new HttpService();
Future> future1 = null;
Future future2 = null;
try {
//lambda表达式写法 java1.8的写法
future1 = executor.submit(() -> rpcService.getRpcResult());
future2 = executor.submit(() -> httpService.getHttpResult());
//这里可以执行其他逻辑任务
//耗时10ms ,300为超时时间
Map result1 = future1.get(300, TimeUnit.MILLISECONDS);
//耗时20ms
Integer result2 = future2.get(300, TimeUnit.MILLISECONDS);
//总耗时20ms
} catch (Exception e) {
if (future1 != null) {
future1.cancel(true);
}
if (future2 != null) {
future2.cancel(true);
}
throw new RuntimeException(e);
}
}
static class RpcService {
Map getRpcResult() throws Exception {
//调用远程方法（远程方法耗时约10ms，可以使用Thread.sleep模拟）
}
}
static class HttpService {
Integer getHttpResult() throws Exception {
//调用远程方法（远程方法耗时约20ms，可以使用Thread.sleep模拟）
}
}
} 注意：强烈建议自己读一下 java.util.concurrent - Java并发工具包 ，这里后续有时间会整理一篇博客
全异步(Callback)
Callback方式调用，使用场景：不考虑回调时间且只能对结果做简单处理（直接写在Future的回调方法中），如果依赖服务是两个或两个以上服务，则不能合并两个服务的处理结果；不阻塞主请求线程，但使用场景有限。
异步回调链式编排
异步回调链式编排（JDK8 CompletableFuture），使用场景：其实不是异步调用方式，只是对依赖多服务的Callback调用结果处理做结果编排，来弥补Callback的不足，从而实现全异步链式调用。下面贴几个简单的使用例子。
//模拟一个任务执行完执行另一个任务
public static void test() throws Exception {
CompletableFuture completableFuture1=CompletableFuture.supplyAsync(()->{
//模拟执行耗时任务
System.out.println("task1 doing...");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//返回结果
return "result1";
});
//等第一个任务完成后，将任务结果传给参数result，执行后面的任务并返回一个代表任务的completableFuture
CompletableFuture completableFuture2= completableFuture1.thenCompose(result->CompletableFuture.supplyAsync(()->{
//模拟执行耗时任务
System.out.println("task2 doing...");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//返回结果
return "result2";
}));
System.out.println(completableFuture2.get());
}