OkHttp流程之Dispatcher

OkHttp的基本流程

android 开发大多用过Okhttp, 在使用过程中,大多也是同步异步两种方式。一般使用方式如下(基于3.14.2版本):

public static final MediaType JSON
    = MediaType.get("application/json; charset=utf-8");

OkHttpClient client = new OkHttpClient();

String post(String url, String json) throws IOException {
       RequestBody body = RequestBody.create(json, JSON);
       Request request = new Request.Builder()
               .url(url)
               .post(body)
               .build();
       //同步
       try (Response response = client.newCall(request).execute()) {
           return response.body().string();
       }

       //异步
      client.newCall(request).enqueue(new Callback(){
        @Override
              public void onFailure(Call call, IOException e) {
              }

              @Override
              public void onResponse( Call call,  Response response) throws IOException {

              }
        });
   }
}

由此可见,无论同步异步其实整个请求大致可以分为三个模块, Request,Call,Response。它们就简单概括了一个网络请求的流程:封装请求Request,进行网络请求Call,返回结果Response. 所以我们在使用过程中只需要对这三个模块进行封装。

OkHttp的线程控制

  • client.newCall

虽然我们将一个网络请求过程简单的归为三个部分,但是其中的细节才是我们需要清楚的。接下来看client.newCall的内容。

/**
 * Prepares the {@code request} to be executed at some point in the future.
 */
@Override public Call newCall(Request request) {
  return RealCall.newRealCall(this, request, false /* for web socket */);
}

newCall 方法返回了一个RealCall这个类实现了Call的接口, 可以认为这个RealCall是Ok中执行网络请求的一个单位。在RealCall中实现了一个请求的同步异步的两个方法execute()和enqueue().

  • RealCall中的真正执行函数

我们看execute和enqueue的伪代码(暂时不用的地方已经省略)

public Response execute() throws IOException {

    try {
      //调用okhttpclient中的分发器去执行
      client.dispatcher().executed(this);
      //将结果直接返回,无论同步异步最终都会调用到getResponseWithInterceptorChain
      //这个函数可以看做是整个okhttp的核心
      return getResponseWithInterceptorChain();
    } finally {
      //执行完需要调用分发器中的结束函数
      client.dispatcher().finished(this);
    }
  }

  public void enqueue(Callback responseCallback) {

    //同样是用dispatcher进行分发,这里是将AsyncCall进行执行
    client.dispatcher().enqueue(new AsyncCall(responseCallback));
  }

AysncCall是RealCall的内部类,这样是为了使用RealCall中的资源,比如okhttpclient,封装的request等等。AsyncCall继承了NameRunnable接口,NameRunable为Runnable的实现,代码如下:

public final void run() {
    //更换执行时候的线程名,主要是为了调试的时候能根据name能明白线程的作用
    String oldName = Thread.currentThread().getName();
    Thread.currentThread().setName(name);
    try {
      //执行此类的抽象方法,NameRunable的子类需要实现这个方法
      execute();
    } finally {
      Thread.currentThread().setName(oldName);
    }
  }

OkHttpClient中的Dispatcher

在上面的code中我们发现,无论是同步异步都会通过 client.dispatcher()这个对象去执行,看这个类名我们也可以猜测出这个类应该是负责线程的分发,可以说这个类算是okhttp的调度中心。既然是线程的分发,那么肯定是涉及到了线程池。我们接下来看看Dispather的庐山真面目。

 //最大并发请求数,
 private int maxRequests = 64;
 // 同一个域名最大连接数是5
 private int maxRequestsPerHost = 5;

 //空闲线程,当dispatcher空闲的时候执行,类似Handler机制中的idleHandler,开发者可视情况选择使用,本文不详述
 private @Nullable Runnable idleCallback;

 //OkHttp 线程池
 private @Nullable ExecutorService executorService;

 //准备执行的保存异步Asyncall的有一个等待队列
 private final Deque readyAsyncCalls = new ArrayDeque<>();

 //保存正在执行AsyncCall的队列
 private final Deque runningAsyncCalls = new ArrayDeque<>();

 //正在执行的同步RealCall队列
 private final Deque runningSyncCalls = new ArrayDeque<>();

Dispatcher就是通过这些内容控制整个过程中线程的并发问题。首先来看线程池的配置

public synchronized ExecutorService executorService() {
    if (executorService == null) {
      //核心线程为0, 最大线程数为MAX_VALUE理论上可以无限制的开辟线程,
      //空闲线程存活60s
      //SynchronousQueue为有界队列,大小为0,只是进行生产消费的传递作用
      executorService = new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60, TimeUnit.SECONDS,
          new SynchronousQueue<>(), Util.threadFactory("OkHttp Dispatcher", false));
    }
    return executorService;
  }

其实看完发现和android提供的newCachedThreadPool很类似,只是改了线程名。我们可以简单分析一下这个线程池的运行机制:

  • 线程池收到runnable因为没有核心线程,所以不需要创建核心线程。所以就直接加入任务队列。
  • 因为SynchronousQueue不保存Runnable,所有接收到线程,就会去检查如果有空闲线程,直接传递给空闲线程,没有的话就开辟一个新的线程去执行。

如果只是这样就会存在一个很大的问题,如果一直这么创建新的线程, 理论上就可以创建无数线程。 这显然不合理。其实这只是okhttp调度线程的一部分,更重要的部分由readyAsyncCalls runningAsyncCalls runningSyncCalls这部分实现。无论是同步还是异步,httpclient封装一个call传递给调度器。在上面提到的execute或者是enqueue函数我们追查下去都会最终到Dispatcher中的promoteAndExecute()方法中。我们以enqueue为例。

Dispatcher.java

void enqueue(AsyncCall call) {
    synchronized (this) {
      //将传递进来的call保存进入readyAsyncCalls队列
      readyAsyncCalls.add(call);
      //找出同域名的请求,如果存在,那么已经存在的call中的callsPerHost数将会被共享,
      //callsPerHost数目表示同一个域名下链接的call的数目
      //callsPerHost为AtomicInteger保证多线程原子操作性,并且保证线程可见为volatile类型
      if (!call.get().forWebSocket) {
        AsyncCall existingCall = findExistingCallWithHost(call.host());
        if (existingCall != null) call.reuseCallsPerHostFrom(existingCall);
      }
    }
    promoteAndExecute();
  }

  private boolean promoteAndExecute() {
    //创建一个新的arraylist保存可执行的call
    List executableCalls = new ArrayList<>();
    boolean isRunning;
    synchronized (this) {
      for (Iterator i = readyAsyncCalls.iterator(); i.hasNext(); ) {
        //遍历准备执行的队列,如果有数据, 需要将数据视情况去执行并将可以执行的放到正在执行队列
        AsyncCall asyncCall = i.next();
        //如果目前正在执行的call大于maxRequest默认是64,那么直接停止退出循环
        if (runningAsyncCalls.size() >= maxRequests) break; // Max capacity.
        //如果这次请求的域名下已经满足最大连接个数(默认是5),那这个call暂时也不能执行
        if (asyncCall.callsPerHost().get() >= maxRequestsPerHost) continue; // Host max capacity.

        i.remove();
        //将call中的表示域名连接数的变量自加1.
        asyncCall.callsPerHost().incrementAndGet();
        //将这个可以执行的call添加到executableCalls链表
        executableCalls.add(asyncCall);
        //同样添加到正在执行的队列
        runningAsyncCalls.add(asyncCall);
      }
      isRunning = runningCallsCount() > 0;
    }

    //遍历executableCalls列表,将每个ayncall添加到线程池去执行
    for (int i = 0, size = executableCalls.size(); i < size; i++) {
      AsyncCall asyncCall = executableCalls.get(i);
      asyncCall.executeOn(executorService());
    }

    return isRunning;
  }

由上面我们可以看出实际最大执行并发数是64, 并不会真的无限制的增加。最大并发线程数与每个域名同时可以连接数都是可以用户自定义的。

Dispatcher.java
//设置最大并发线程数
public void setMaxRequests(int maxRequests)

//设置相同域名最大并发数
public void setMaxRequestsPerHost(int maxRequestsPerHost)

看到这里我们已经清楚了,call是怎样执行的,同时我们会有疑问,插入和移出必须是成对出现的,线程执行的时候添加到running队列了。那么什么时候移出队列呢?这就要我们继续看AsyncCall的实际执行函数了。
AysncCall的父类NamedRunnable可以当做一个Runnable,从上文我们得知,在它的run方法中都需要执行 execute()方法,而这个方法是抽象方法,需要每个子类去实现。我们看看Ayncall中发生了什么。

RealCall.AsyncCall

 protected void execute() {
      try {
        //获取执行结果
        Response response = getResponseWithInterceptorChain();
        signalledCallback = true;
        //回调将结果返回调用者
        responseCallback.onResponse(RealCall.this, response);
      } catch (IOException e) {
        if (signalledCallback) {
          // Do not signal the callback twice!
          Platform.get().log(INFO, "Callback failure for " + toLoggableString(), e);
        } else {
          //如果发生异常产生错误回调
          responseCallback.onFailure(RealCall.this, e);
        }
      } finally {
        //执行完之后,调用dispatcher中的finish函数
        client.dispatcher().finished(this);
      }
    }
  }

  //我们进一步看看Dispatcher中的finish函数
  Dispatcher.java

  //这个类重载了多个finished方法,最终调用到这个私有函数里面
  private  void finished(Deque calls, T call) {
  Runnable idleCallback;
  synchronized (this) {
    //将队列中的元素删除,如果没有这个元素会抛出异常
    if (!calls.remove(call)) throw new AssertionError("Call wasn't in-flight!");
    idleCallback = this.idleCallback;
  }

  boolean isRunning = promoteAndExecute();
  //如果队列没有在执行的线程且idle线程不为空则执行。 可以看出每个线程结束完都会检查一遍是不是
  //要执行空闲线程
  if (!isRunning && idleCallback != null) {
    idleCallback.run();
  }
}

总结

以上就是okhttp大致的调度逻辑,本篇文章不涉及各种拦截器的分析。所以我们可以将请求的逻辑分为三个模块

  • 封装Request。
  • 封装RealCall提交到调度器Dispatcher去执行
  • 将结果返回

你可能感兴趣的:(Android,okhttp流程,okhttp源码解析,dispatcher)