OkHttp3原始碼解析(一)之請求流程

xxq2dream發表於2018-09-10
HTTP原始碼

OKHttp3原始碼解析系列

本文基於OkHttp3的3.11.0版本

implementation `com.squareup.okhttp3:okhttp:3.11.0`

OkHttp3發起請求方式

我們用OkHttp3發起一個網路請求一般是這樣：

首先要構建一個OkHttpClient

OkHttpClient.Builder builder = new OkHttpClient.Builder()
        .connectTimeout(15, TimeUnit.SECONDS)
        .writeTimeout(20, TimeUnit.SECONDS)
        .readTimeout(20, TimeUnit.SECONDS);
mOkHttpClient = builder.build();

然後構建Request

Request request = new Request.Builder()
        .url(url)
        .build();

非同步請求

mOkHttpClient.newCall(request).enqueue(callback);

同步請求

mOkHttpClient.newCall(request).execute();

以上是簡略的用OkHttp3請求網路的步驟，下面我們來通過原始碼分析下。

OkHttp3原始碼分析

我們先來看看OkHttp的newCall方法

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

可以看見返回的RealCall，所以我們發起請求無論是呼叫execute方法還是enqueue方法，實際上呼叫的都是RealCall內部的方法。

//RealCall.class
@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);
    }
}

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

在RealCall內部的enqueue方法和execute方法中，都是通過OkHttpClient的任務排程器Dispatcher來完成。下面我們先來看看Dispatcher。

任務排程器Dispatcher

Dispatcher中有一些重要的變數

//最大併發請求數
private int maxRequests = 64;
//每個主機的最大請求數
private int maxRequestsPerHost = 5;

//這個是執行緒池，採用懶載入的模式，在第一次請求的時候才會初始化
private @Nullable ExecutorService executorService;

//將要執行的非同步請求任務佇列
private final Deque<AsyncCall> readyAsyncCalls = new ArrayDeque<>();

//正在執行的非同步請求任務佇列
private final Deque<AsyncCall> runningAsyncCalls = new ArrayDeque<>();

//正在執行的同步請求佇列
private final Deque<RealCall> runningSyncCalls = new ArrayDeque<>();

我們再看看Dispatcher的構造方法

public Dispatcher(ExecutorService executorService) {
    this.executorService = executorService;
}

public Dispatcher() {
}

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

（1）可以看到Dispatcher有2個方法，我們如果需要用自己的執行緒池，可以呼叫帶有執行緒池引數的構造方法。

（2）Dispatcher中的預設構造方法是個空實現，執行緒池的載入方式採用的是懶載入，也就是在第一次呼叫請求的時候初始化。

（3）Dispatcher採用的執行緒池類似於CacheThreadPool，沒有核心執行緒，非核心執行緒數很大，比較適合執行大量的耗時較少的任務。

（4）由於沒有提供帶有最大併發請求數和每個主機的最大請求數引數的構造方法，我們沒辦法修改這2個引數。

下面我們分別分析下同步請求和非同步請求的流程

同步請求流程分析

我們在通過mOkHttpClient.newCall(request).execute()的方式發起同步請求時，實際上呼叫的是RealCall內部的execute方法。

//RealCall.class
@Override public Response execute() throws IOException {
    ...
    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);
    }
}

RealCall內部的execute方法主要做了3件事：

（1）執行Dispacther的executed方法，將任務新增到同步任務佇列中

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

（2）呼叫RealCall內部的 getResponseWithInterceptorChain 方法請求網路。

（3）無論最後請求結果如何，都會呼叫Dispatcher的finished方法，將當前的請求移出佇列。

void finished(RealCall call) {
    finished(runningSyncCalls, call, false);
}

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!");
      //這裡promoteCalls為false，所以不會呼叫promoteCalls方法
      if (promoteCalls) promoteCalls();
      runningCallsCount = runningCallsCount();
      idleCallback = this.idleCallback;
    }
    
    if (runningCallsCount == 0 && idleCallback != null) {
      idleCallback.run();
    }
}

總結

綜上流程分析來看，同步請求只是利用了Dispatcher的任務佇列管理，沒有利用Dispatcher的執行緒池，所以executed方法是在請求發起的執行緒中執行的。所以我們不能直接在UI執行緒中呼叫OkHttpClient的同步請求，否則會報“NetworkOnMainThread”錯誤。

非同步請求流程分析

我們通過 mOkHttpClient.newCall(request).enqueue(callback) 的方式發起非同步請求，實際上呼叫的是RealCall中的enqueue方法。

//RealCall.class
@Override 
public void enqueue(Callback responseCallback) {
    ...
    client.dispatcher().enqueue(new AsyncCall(responseCallback));
}

RealCall中的enqueue方法什麼也沒幹，直接呼叫Dispatcher中的enqueue方法，不過將傳入的Callback包裝成了AsyncCall。AsyncCall是RealCall中的內部類。

final class AsyncCall extends NamedRunnable {
    private final Callback responseCallback;

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

    ...

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

（1）AsyncCall實現了繼承自NamedRunnable，而NamedRunnable實現了Runnable介面，在run方法中會呼叫execute方法，所以當執行緒池執行AsyncCall時，AsyncCall的execute方法就會被呼叫。

（2）AsyncCall的execute方法通過getResponseWithInterceptorChain方法請求網路得到Response，然後根據請求狀態回撥對應的方法。所以這些回撥方法都是執行線上程池中的，不能直接更新UI。

（3）AsyncCall的execute方法無論請求結果如何，最後都會呼叫Dispatcher的finished方法。

//Dispatcher.class
void finished(AsyncCall call) {
    //與同步任務的情況不同，這裡promoteCalls引數為true
    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!");
      //非同步任務時，這裡會呼叫promoteCalls方法
      if (promoteCalls) promoteCalls();
      runningCallsCount = runningCallsCount();
      idleCallback = this.idleCallback;
    }

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

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.
    }
}

與同步請求呼叫finished方法不同的是，非同步任務呼叫Dispatcher的finished方法時還會執行promoteCalls方法。promoteCalls方法主要就是從待執行的任務佇列中取出一個任務加入到正在執行的任務佇列，並呼叫執行緒池執行任務。

最後我們來看看Dispatcher中的enqueue方法

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

enqueue方法比較簡單，如果當前正在執行的任務數量還沒達到最大數量並且當前請求的任務所請求的主機對應的請求數沒有超過最大閾值，就將當前任務加入正在執行的任務佇列，並呼叫執行緒池執行，否則就將任務加入待執行的佇列。

總結

（1）綜上，非同步請求利用了Dispatcher的執行緒池來處理請求。當我們發起一個非同步請求時，首先會將我們的請求包裝成一個AsyncCall，並加入到Dispatcher管理的非同步任務佇列中，如果沒有達到最大的請求數量限制，就會立即呼叫執行緒池執行請求。

（2）AsyncCall執行的請求回撥方法都是線上程池中呼叫的，所以我們不能直接更新UI，需要在回撥方法中利用Handler切換執行緒。

歡迎關注我的微信公眾號，和我一起每天進步一點點！
AntDream

相關文章