怎么利用异步设计提升系统性能？

异步是一种程序设计的思想，使用异步模式设计的程序可以显著减少线程等待，从而在高吞吐量的场景中，极大提升系统的整体性能，降低请求时延。
同步设计流程

我们假设要做一个转账的业务，即从账户A中转账100元到账户B中，它包含2步：

• 从A的账户中减少100元
  
• 给B的账户增加100元
  

我们可以设计2个Service：

• Transfer服务，负责转账，接口是Transfer(A, B, 100)
  
• Account服务，负责账户管理，接口是Add(A, -100)和Add(B, 100)
  

转账业务的伪代码如下：

1. Transfer(accountFrom, accountTo, amount){
2.     Add(accountFrom, -1*amount)
3.     Add(accountTo, 1*amount)
4.     return OK
5. }

复制代码

假设Add操作的平均响应时延是50ms，那么我们的Transfer操作平均实验大约是100ms。在实际运行过程中，每处理一次Transfer操作，需要耗时100ms，并且在100ms内需要独占一个线程，即每个线程每秒最多可以处理10次Transfer操作。
假设我们在一个服务器上同时打开的线程数量上限是10000，那么这个服务器每秒可以处理的请求上限是：10000*10 = 100000次。
当客户请求数量超过上限时，请求就需要排队，那么Transfer操作的响应时延变成：排队等待时延+处理时延（100ms），即在大量请求的场景中，我们的服务响应时延增加了。
但是，在这种情况下，服务器的资源并没有被消耗很多，例如CPU、内存、网卡等资源都很空闲，我们的100000个线程大部分时间在等待Add操作返回结果。
上面就是同步设计方式，在这种情况下，整个服务器的所有线程大部分时间都没有在工作，而是在等待。
异步设计流程

对于同样的业务场景，我们来看一下异步方式下的伪代码：

1. TransferAsync(accountFrom, accountTo, amount, OnComplete){
2.     AddAsync(accountFrom, -1*amount, OnDebit(accountTo, 1*amount, OnAllDone(OnComplete)))
3. }
5. OnDebit(amountTo, amount, OnAllDone(OnComplete)){
6.     AddAsync(accountTo, amount, OnAllDone(OnComplete))
7. }
9. OnAllDone(OnComplete){
10.     OnComplete()
11. }

复制代码

这里TransferAsync和之前的Transfer相比，增加了一个参数，这个参数是一个回调方法OnComplete()。
上面方法的语义：请帮我执行转账操作，当转账完成后，请调用OnComplete（）方法，调用TransferAsync的线程不必等待转账完成就可以立即返回，当转账结束后，OnComplete()方法会被调用来执行后续的工作。
上面代码中，我们定义了2个回调方法：

• OnDebit()：扣减账户accountFrom完成后调用的回调方法
  
• OnAllDone()：转入账户accountTop完成后调用的回调方法
  

整个异步操作的语义如下：

• 异步从accountFrom的账户中减去相应的钱数，然后调用OnDebit方法
  
• 在OnDebit方法中，异步把减去的钱数加到accountTop账户中，然后执行OnAllDone方法
  
• 在OnAllDone方法中，调用OnComplete方法
  

采用异步方式后，整个流程的时序和同步实现是完全一样的，区别在于线程模型由同步顺序调用改为异步调用和回调的机制。
由于流程的时序和同步方式相同，在低请求量的场景下，平均响应时延还是100ms，在超高请求量的场景下，异步机制不需要线程等待执行结果，只需要个位数的线程，即可实现同步场景大量线程一样的吞吐量。
在异步模式下，由于没有了线程数量上的限制，总体吞吐量上限会大大超过同步实现，并且在服务器CPU、网络带宽资源达到极限之前，响应时延不会随着请求数量增加而显著升高，几乎可以一直保持100ms左右的响应时延。
异步框架：CompletableFuture

Java语言中常用的异步框架包括CompletableFuture和RxJava，我们主要来看CompletableFuture。
它是Java 8中新增的一个强大的异步编程的类，包括了我们在开发异步程序过程中需要的大部分功能。
针对上述的转账场景，我们来看一下如何使用CompletableFuture实现。
首先定义2个接口：

1. public interface AccountService {
3.     CompletableFuture<Void> add(int account, int amount);
4. }

复制代码

1. public interface TransferService {
3.     CompletableFuture<Void> transfer(int fromAccount, int toAccount, int amount);
4. }

复制代码

然后实现转账功能：

1. public class TransferServiceImpl implements TransferService {
2.     @Inject
3.     private  AccountService accountService;
5.     @Override
6.     public CompletableFuture<Void> transfer(int fromAccount, int toAccount, int amount) {
7.       return accountService.add(fromAccount, -1 * amount)
8.         .thenCompose(v -> accountService.add(toAccount, amount));   
9.     }
10. }

复制代码

客户端调用TransferService时，可以使用同步方式，也可以使用异步方式：

1. public class Client {
2.     @Inject
3.     private TransferService transferService;
4.     private final static int A = 1000;
5.     private final static int B = 1001;
7.     public void syncInvoke() throws ExecutionException, InterruptedException {
8.         // 同步调用
9.         transferService.transfer(A, B, 100).get();
10.         System.out.println("转账完成！");
11.     }
13.     public void asyncInvoke() {
14.         // 异步调用
15.         transferService.transfer(A, B, 100)
16.             .thenRun(() -> System.out.println("转账完成！"));
17.     }
18. }

复制代码

异步设计的思想：当我们要执行一项比较耗时的操作时，不去等待操作结束，而是给这个操作一个命令：“当操作完成后，接下来去执行什么”。
使用异步编程带来的好处是可以减少或者避免线程等待，只用很少的线程就可以达到超高的吞吐能力。
使用异步编程带来的问题是复杂度增加，代码可读性和可维护性会下降。
　　　　出处：http://wing011203.cnblogs.com/　　　　本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。
来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！