OkHttp3-只会用是不够的，还得懂这些，android系统四层架构

a).同步请求execute()

@Override
public Response execute() throws IOException {
synchronized (this) {
//一个请求只能执行一次
if (executed) throw new IllegalStateException(“Already Executed”);
executed = true;
}
captureCallStackTrace();
timeout.enter();
//http请求调用的生命周期
eventListener.callStart(this);
try {
client.dispatcher().executed(this);//注释1
Response result = getResponseWithInterceptorChain();//注释2
if (result == null) throw new IOException(“Canceled”);
return result;
} catch (IOException e) {
e = timeoutExit(e);
eventListener.callFailed(this, e);
throw e;
} finally {
client.dispatcher().finished(this);
}
}

关键代码为标出来的注释1和注释2两处，先看注释1，看下client.dispatcher()返回的Dispatcher对象:

/**
* Policy on when async requests are executed.
*
* 

Each dispatcher uses an {@link ExecutorService} to run calls internally. If you supply your
* own executor, it should be able to run {@linkplain #getMaxRequests the configured maximum} number
* of calls concurrently.
/public final class Dispatcher {
//最大请求数
private int maxRequests = 64;
//每一个主机的最大请求数
private int maxRequestsPerHost = 5;
private @Nullable Runnable idleCallback;
/* Executes calls. Created lazily. /
//线程池
private @Nullable ExecutorService executorService;
/* Ready async calls in the order they’ll be run. /
//准备执行的异步请求队列
private final Deque readyAsyncCalls = new ArrayDeque<>();
/* Running asynchronous calls. Includes canceled calls that haven’t finished yet. /
//正在执行的异步请求队列
private final Deque runningAsyncCalls = new ArrayDeque<>();
/* Running synchronous calls. Includes canceled calls that haven’t finished yet. /
//正在执行的同步请求队列
private final Deque runningSyncCalls = new ArrayDeque<>();
public Dispatcher(ExecutorService executorService) {
this.executorService = executorService;
}
void enqueue(AsyncCall call) {
synchronized (this) {
readyAsyncCalls.add(call);
// Mutate the AsyncCall so that it shares the AtomicInteger of an existing running call to
// the same host.
if (!call.get().forWebSocket) {
AsyncCall existingCall = findExistingCallWithHost(call.host());
if (existingCall != null) call.reuseCallsPerHostFrom(existingCall);
}
}
promoteAndExecute();
}
/* Used by {@code Call#execute} to signal it is in-flight. */
synchronized void executed(RealCall call) {
runningSyncCalls.add(call);
}
//…代码略…
}

这是一个调度器，内部维护着最大请求数，每个主机最大请求数等参数，最重要的是维护着三个队列，分别是“将要执行的异步请求队列”、“正在执行的异步请求队列”和“正在执行的同步执行队列”。之前的代码段中注释1处调用dispatcher.executed(this)方法，我们看到这个方法只是把当前的realCall实例加入到了请求队列中。接下来看注释2处的代码Response result = getResponseWithInterceptorChain()，看下这个方法：

Response getResponseWithInterceptorChain() throws IOException {
// Build a full stack of interceptors.
List interceptors = new ArrayList<>();
//用户自定义的拦截器
interceptors.addAll(client.interceptors());
//错误重连、重定向拦截器
interceptors.add(retryAndFollowUpInterceptor);
//请求配置拦截器
interceptors.add(new BridgeInterceptor(client.cookieJar()));
//缓存拦截器
interceptors.add(new CacheInterceptor(client.internalCache()));
//连接拦截器
interceptors.add(new ConnectInterceptor(client));
if (!forWebSocket) {
interceptors.addAll(client.networkInterceptors());
}
//发起请求访问服务器的拦截器
interceptors.add(new CallServerInterceptor(forWebSocket));