如果要说OkHttp中的大头，Dispatcher肯定是占据一席之地的。在OkHttp中，Dispatcher负责任务的分发和调度。今天来重点的说说它。
  其实这个类非常的简单，大家不要将它想的太难了。

1. 同步请求的Dispatcher

  同步请求是通过Call的execute方法来执行的，虽然我们在分析同步请求时，已经看过这个方法了，但是在这里我们还是再来看一遍，这一次我们只关心Dispatcher相关的操作：

  @Override public Response execute() throws IOException {
    synchronized (this) {
      if (executed) throw new IllegalStateException("Already Executed");
      executed = true;
    }
    captureCallStackTrace();
    eventListener.callStart(this);
    try {
      client.dispatcher().executed(this);
      Response result = getResponseWithInterceptorChain();
      if (result == null) throw new IOException("Canceled");
      return result;
    } catch (IOException e) {
      eventListener.callFailed(this, e);
      throw e;
    } finally {
      client.dispatcher().finished(this);
    }
  }

  我们从这段代码可以看出来，在调用getResponseWithInterceptorChain方法之前，我们首先Dispatcher的executed方法，我们来看看在这个方法是怎么进行操作.

synchronized void executed(RealCall call) {
    runningSyncCalls.add(call);
  }

  同步请求的操作非常简单，直接将当前这个Call添加到runningSyncCalls队列，就没有做其他的事情了。
  同时在execute方法的最后，还调用了Dispatcher的finished方法。我猜，肯定是将当前的Call对象从队列中移除。
  同步请求的Dispatcher过程就是这么简单。接下来，我们来看看异步请求的Dispatcher过程。

2. 异步请求的Dispatcher

  异步请求是通过Call的enqueue方法来执行的，我们来看看：

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

  异步执行的核心在enqueue方法最后一行。我们来看看Dispatcher的enqueue方法:

  synchronized void enqueue(AsyncCall call) {
    if (runningAsyncCalls.size() < maxRequests && runningCallsForHost(call) < maxRequestsPerHost) {
      runningAsyncCalls.add(call);
      executorService().execute(call);
    } else {
      readyAsyncCalls.add(call);
    }
  }

  这个方法在上一篇文章中已经分析过了，这这里就不在做过多的解释，这里我们需要注意的一点是：当不满足if条件时，会将当前的Call对象放在一个等待队列中，但是什么时候将当前这个Call从等待队列移除呢？这个就是Dispatcher的职责了。关于这个问题，我们需要从AsyncCall的execute方法，我们来看看：

    @Override protected void execute() {
      boolean signalledCallback = false;
      try {
        Response response = getResponseWithInterceptorChain();
        if (retryAndFollowUpInterceptor.isCanceled()) {
          signalledCallback = true;
          responseCallback.onFailure(RealCall.this, new IOException("Canceled"));
        } else {
          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 {
          eventListener.callFailed(RealCall.this, e);
          responseCallback.onFailure(RealCall.this, e);
        }
      } finally {
        client.dispatcher().finished(this);
      }
    }
  }

  我们重点关注如下代码：

client.dispatcher().finished(this);

  如上的代码最终会执行到Dispatcher的finished方法中去：

  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();
    }
  }

  而在调用finished时，promoteCalls参数我们传入的是true,所以会调用promoteCalls方法，最后，我们可以这个方法里面来找到答案：

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

    for (Iterator<AsyncCall> i = readyAsyncCalls.iterator(); i.hasNext(); ) {
      AsyncCall call = i.next();

      if (runningCallsForHost(call) < maxRequestsPerHost) {
        i.remove();
        runningAsyncCalls.add(call);
        executorService().execute(call);
      }

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

  从上面的代码中，我们可以看出来，当当前的执行队列不是满的的话，就会从等待队列去取出相应的Call放入执行队列中去，并且提交到线程池去执行。
  这就是异步请求的任务调度过程，是不是也是非常的简单？

3.总结

  同步请求的调度过程是非常简单的，这里就不对同步做总结，而对异步请求做一个简单的总结。
  1. 异步请求通过调用Call的enqueue方法将一个Call对象放入到一个队列当中，如果当前的执行队列没有满的话，就放在执行队列中，立即执行；如果满了的话，就放在等待队列中去。
  2.异步请求，当一个任务执行完毕之后，会调用Dispatcher的finished方法。在finished方法里面，会调用promoteCalls方法会重新调整队列。