okHttp3 线程池

先来做一个简单的网络请求

Request request = new Request.Builder()
                .url("http://www.baidu.com")
                .build();

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

            }

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

            }
        });

我们可以看到请求中使用了 client.newCall

  @Override public Call newCall(Request request) {
    return new RealCall(this, request, false /* for web socket */);
  }

在 newCall 里其实返回的是 RealCall，所以 client.newCall(request).enqueue() 其实是调用 RealCall 的 enqueue 方法

  @Override public void enqueue(Callback responseCallback) {
    synchronized (this) {
      if (executed) throw new IllegalStateException("Already Executed");
      executed = true;
    }
    captureCallStackTrace();
    client.dispatcher().enqueue(new AsyncCall(responseCallback));
  }

在 client.dispatcher().enqueue() 时传入了 AsyncCall 对象，AsyncCall 是 RealCall 的内部类，实际上是一个 Runnable；

final class AsyncCall extends NamedRunnable

所以我们回头看下 client.dispatcher().enqueue(Runnable) 这个方法得处理

synchronized void enqueue(AsyncCall call) {
    if (runningAsyncCalls.size() < maxRequests && runningCallsForHost(call) < maxRequestsPerHost) {
      // 在运行队列 runningAsyncCalls 添加任务
      runningAsyncCalls.add(call);
      // 这里就是线程池的处理
      executorService().execute(call);
    } else {
      // 在等待队列 readyAsyncCalls 添加任务
      readyAsyncCalls.add(call);
    }
  }

其中 executorService() 这个方法是创建线程池的方法，这里用到了 ThreadPoolExecutor，可以看和 newCachedThreadPool 线程池的处理基本一致，可以看下 ThreadPoolExecutor 线程池原理

  public synchronized ExecutorService executorService() {
    if (executorService == null) {
      executorService = new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60, TimeUnit.SECONDS,
          new SynchronousQueue<Runnable>(), Util.threadFactory("OkHttp Dispatcher", false));
    }
    return executorService;
  }

SynchronousQueue 这个等待队列里是没有任务，每一个插入操作(offer)必须等待另一个线程对应的移除操作(poll),反之亦然;

在上面有个判断 if (runningAsyncCalls.size() < maxRequests && runningCallsForHost(call) < maxRequestsPerHost) 如果这个不成立的时候是要把任务放在 readyAsyncCalls 里，那么我们什么时候去取这里的任务来执行呢，看下刚才说的 runnable 就是 AsyncCall

  final class AsyncCall extends NamedRunnable {
    private final Callback responseCallback;

    AsyncCall(Callback responseCallback) {
      super("OkHttp %s", redactedUrl());
      this.responseCallback = responseCallback;
    }

    String host() {
      return originalRequest.url().host();
    }

    Request request() {
      return originalRequest;
    }

    RealCall get() {
      return RealCall.this;
    }

    @Override protected void execute() {
      boolean signalledCallback = false;
      try {
        // 网络请求的实际操作
        Response response = getResponseWithInterceptorChain();
        if (retryAndFollowUpInterceptor.isCanceled()) {
          signalledCallback = true;
          // onFailure 回调
          responseCallback.onFailure(RealCall.this, new IOException("Canceled"));
        } else {
          signalledCallback = true;
          // onResponse 回调
          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 {
        client.dispatcher().finished(this);
      }
    }
  }

看到 finally 有个 runnable 结束的处理 client.dispatcher().finished(this); 看下里面的 finished 方法

  void finished(AsyncCall call) {
    finished(runningAsyncCalls, call, true);
  }

  private <T> void finished(Deque<T> calls, T call, boolean promoteCalls) {
    int runningCallsCount;
    Runnable idleCallback;
    synchronized (this) {
      if (!calls.remove(call)) throw new AssertionError("Call wasn't in-flight!");
      if (promoteCalls) promoteCalls();
      runningCallsCount = runningCallsCount();
      idleCallback = this.idleCallback;
    }

    if (runningCallsCount == 0 && idleCallback != null) {
      idleCallback.run();
    }
  }

处理的地方在 promoteCalls 这个方法里

  private void promoteCalls() {
    if (runningAsyncCalls.size() >= maxRequests) return; // Already running max capacity.
    if (readyAsyncCalls.isEmpty()) return; // No ready calls to promote.

    // 遍历 readyAsyncCalls，把任务取出来
    for (Iterator<AsyncCall> i = readyAsyncCalls.iterator(); i.hasNext(); ) {
      AsyncCall call = i.next();

      if (runningCallsForHost(call) < maxRequestsPerHost) {
        i.remove();
        // 取出来的任务加入 runningAsyncCalls
        runningAsyncCalls.add(call);
        // 把任务放入线程池
        executorService().execute(call);
      }

      if (runningAsyncCalls.size() >= maxRequests) return; // Reached max capacity.
    }
  }

所以在请求任务数大于 maxRequests 并且相同 host 最大请求数大于 maxRequestsPerHost，就会把请求任务放在 readyAsyncCalls 队列里，当线程池里执行任务的 runnable 执行完任务在最后会检查 readyAsyncCalls 里有没有任务，如果有任务并且是同一个 host 就放入到线程池中执行，所以就是通过这个方法不断地从 readyAsyncCalls 队列里取出任务，对线程池里的线程进行复用。