同步调用就不多说了,先来看看异步调用的好处:
使用异步调用可以不用一直等待一个方法执行完成,可以同时调用多个方法,大多数情况下对于无关联的方法
完全可以分别去执行。

 Future

先从java中的Future来看吧：

我们在使用线程池的时候经常会遇到如下几个类，有着如下的关系:

Runnable  实现此接口的任务线程无返回结果

Callable  实现此接口的任务线程有返回结果

Future    代表着未来的接口,提供了如下几个方法,具体的实现都在FutureTask中
boolean cancel(boolean mayInterruptIfRunning);
boolean isCancelled();
boolean isDone();
V get() throws InterruptedException, ExecutionException;
V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;

RunnableFuture   extends Runnable, Future<V>

FutureTask       implements RunnableFuture<V>
调用其get方法,如果任务没有执行完成则会阻塞。这里简单理解如何实现异步调用,如果你的方法想立刻方法,
则可以立刻返回一个FutureTask,想获取方法执行的结果则调用其get方法,但是如果任务还没执行完成,调用get
方法也会阻塞。       

简单使用:
public static void main(String[] args) throws ExecutionException, InterruptedException {

    Future<Integer> f1=exec.submit(()->{
        LockSupport.parkNanos(TimeUnit.SECONDS.toNanos(1));
        return 1;
    });

    Future<Integer> f2=exec.submit(()->{
        LockSupport.parkNanos(TimeUnit.SECONDS.toNanos(2));
        return 2;
    });

    int result=f1.get()+f2.get();
}
具体结果和执行时间大家自己体会一下。

FutureTask

我们来看看FutureTask是怎么实现的：
首先你提交的线程任务都会被包装为FutureTask
public <T> Future<T> submit(Callable<T> task) {
    if (task == null) throw new NullPointerException();
    RunnableFuture<T> ftask = newTaskFor(task);
    execute(ftask);
    return ftask;
}
protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
    return new FutureTask<T>(callable);
}

线程池最终会调用其run()方法
我们先来看看其get方法
public V get() throws InterruptedException, ExecutionException {
    int s = state;
    if (s <= COMPLETING)
        s = awaitDone(false, 0L);
    return report(s);
}
当调用get方法的时候,首先会判断任务状态是否已经完成，如果没有完成则就会进行阻塞等待。

public void run() {
        ...
    result = c.call();
        ran = true;
        
        if (ran)
          set(result);
        ...
}

在执行run方法的时候会调用call方法,执行完成后会唤醒执行阻塞的get().
具体阻塞和唤醒可以看源码深入了解一下。

RPC框架中的同步和异步调用

这里来看看在RPC框架Motan中是怎么实现的:
Motan中自己实现了如下几个类:
Future
Response
DefaultResponse
DefaultResponseFuture
FutureListener

首先自己定义了Future和Response接口,然后定义了ResponseFuture接口。
通过名称可以知道Future相关的都代表着未来也就是异步调用会使用。
可以看到对于同步返回和异步的返回分别有其对应的实现类:
DefaultResponse implements Response
DefaultResponseFuture implements ResponseFuture
这里的DefaultResponseFuture 类似我们上面讲到的FutureTask.

DefaultResponseFuture :
我们来看看其具体的实现
DefaultResponseFuture 中实现的 getValue() 方法类型FutureTask中的get方法,会进行阻塞直到结果返回。
它是利用protected Object lock = new Object();来实现的阻塞。
synchronized (lock){
  if (!isDoing()) {
     return getValueOrThrowable();//如果不是在运行就报错
  }
  
  if (timeout <= 0) {//超时时间
    try {
        lock.wait();
    } catch (Exception e) {
        ...
    }
    //System.out.println("<= 0  getValueOrThrowable");
    return getValueOrThrowable();
  }
  ...部分代码
}

可以看到这里也是先判断任务是否还在运行,如果还在运行就会调用lock.wait();进行阻塞。
那是什么时候来lock.notifyAll()的呢?我们先看完同步调用的DefaultResponse 是如何实现的在来看
这个问题。

DefaultResponse ：
我们先找到NettyClient中具体发送请求的request方法:
private Response request(Request request, boolean async) throws TransportException {
    Channel channel;
    Response response;
    try {
        // async request 异步
        response = channel.request(request);
    } catch (Exception e) {

    }
    // aysnc or sync result
    response = asyncResponse(response, async);
    return response;
}

在NettyChannel类中又实现了request方法:

public Response request(Request request) throws TransportException {
   
    ResponseFuture response = new DefaultResponseFuture(request, timeout, 
    this.nettyClient.getUrl());
    this.nettyClient.registerCallback(request.getRequestId(), response);
    byte[] msg = CodecUtil.encodeObjectToBytes(this, codec, request);
    ChannelFuture writeFuture = this.channel.writeAndFlush(msg);
    boolean result = writeFuture.awaitUninterruptibly(timeout, TimeUnit.MILLISECONDS);

    ...
    return response;
}

可以看到返回出去的response其实是DefaultResponseFuture.

再回到NettyClient中的方法:
private Response asyncResponse(Response response, boolean async) {
    if (async || !(response instanceof ResponseFuture)) {
        //心跳消息也会异步发送
        return response;
    }
    return new DefaultResponse(response);//同步获取
}

可以看到如果是同步则会返回DefaultResponse.并且将DefaultResponseFuture包装到DefaultResponse中.
所以同步调用其实也是借助了DefaultResponseFuture的功能。

我们来看看DefaultResponse的构造函数:
public DefaultResponse(Response response) {
    this.value = response.getValue();
    this.exception = response.getException();
    this.requestId = response.getRequestId();
    this.processTime = response.getProcessTime();
    this.timeout = response.getTimeout();
}
可以看到会直接调用response.getValue();也就是DefaultResponseFuture的getValue()方法。
我们上面讲了什么呢?DefaultResponseFuture的getValue()方法会怎么样呢?当然是阻塞到结果返回。

到这里我们可以看到如果是同步调用则会等到结果返回后才会返回response.而异步调用则是先返回
DefaultResponseFuture，等到想获取结果的时候则可以调用其get方法。

那我们解决最后一个问题吧,什么时候调用了lock.notifyAll(),让结果返回的。

答案是onSuccess方法。
在NettyClient中客户端获取到服务端的返回后会调用如下的handler方法:
@Override
public Object handle(Channel channel, Object message) {
    Response response = (Response) message;
    System.out.println("获取到message");
    ResponseFuture responseFuture = NettyClient.this.removeCallback(response.getRequestId());
    ...
    if (response.getException() != null) {
        responseFuture.onFailure(response);
    } else {
        responseFuture.onSuccess(response);
    }
    return null;
}

我们发现这里会调用DefaultResponseFuture的onsuccess方法:
public void onSuccess(Response response) {
    this.result = response.getValue();
    this.processTime = response.getProcessTime();
    done();
}
到这里就知道了,一切都在这个done方法里面了:
protected boolean done() {
    synchronized (lock) {
        if (!isDoing()) {//默认doing   如果不是这个状态就返回
            return false;
        }
         //System.out.println("done");
        state = FutureState.DONE;//运行完毕
        //System.out.println("notifyAll");
        lock.notifyAll();
    }

    notifyListeners();
    return true;
}

终于看到我们想看到的lock.notifyAll();方法了。

 总结

 通过分析Motan中的实现，可以看到整体思路和futureTask很类型,因此真的有必要学好基础的思想。加油。