定义：Okhttp是对Socket的封装。有三个主要的类，Request，Response，Call
默认使用new OkHttpClient() 创建初client对象。
如果需要初始化网络请求的参数，如timeout,interceptor等，可以创建Builder，通过builder.build() 创建初client对象。
三个问题
1.请求发送到什么哪去了？框架里放到哪里了？
请求通过execute方法发送到框架中的两个队列中去了:运行中的队列；等待中的队列，如果说运行中的队列总数小于64并且访问同一目标机器请求小于5，就进入运行队列，否则进入等待队列
2.请求被谁处理：请求提交到运行中队列后，交给线程池来处理，直接处理请求
3.请求是怎么被维护的：每次请求完成后，client.dispath调用finished方法，对运行中的队列和等待中的队列进行数据处理，（在符合条件的情况下，将等待中的加入到运行中队列中去）
流程
1.通过
生成一个OkHttpClient client = new OkHttpClient();
2.构建一个Request requet = new Request.Builder()
.get().url("https:www.baidu.com").build();
3.通过client.newCall(request)得到Call,这个call是他的子类RealCall
4.通过call.execute(同步) 或call.enqueue(异步)启动
A：执行Execute
@Override public Response execute() throws IOException {
synchronized (this) {
if (executed) throw new IllegalStateException("Already Execu
ted"); // (1)
executed = true;
}
try { client.dispatcher().executed(this);
// (2)
Response result = getResponseWithInterceptorChain();
// (3)
if (result == null) throw new IOException("Canceled");
return result;
} finally {
client.dispatcher().finished(this); // (4)
} }
1.先判断这个call是否被执行了，每个call只能被执行一次，如果要一个完成一样的call可以利用call的clone方法进行克隆
2.利用client.dispathcer().execute(this)来进行执行,其中dispatcher.execute方法为
synchronized void executed(RealCall call) {
runningSyncCalls.add(call);
}
这里我刚开始没有相同，之后他加入队列后怎么调用的，后来发现在 下一个方法调用的
3.调用getResponseWithInterceptorChain函数来获取HTTP返回的结果,这里的originalRequest就是我们的请求刚刚加入队列的是RealCall，通过chain.proceed(originalRequest)去调用
private Response getResponseWithInterceptorChain() throws IOException {
// Build a full stack of interceptors.
List<Interceptor> 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 (!retryAndFollowUpInterceptor.isForWebSocket()) {
interceptors.addAll(client.networkInterceptors());
}
interceptors.add(new CallServerInterceptor(
retryAndFollowUpInterceptor.isForWebSocket()));
Interceptor.Chain chain = new RealInterceptorChain(
interceptors, null, null, null, 0, originalRequest);
return chain.proceed(originalRequest);
}
4.最后还要通知dispathcer自己已经执行完毕
client.dispatcher().finished(this);
会执行finished（队列、call,true）
其中这个方法是同步和异步都调用的方法，通过第三个参数，是否执行promoteCall方法具体的执行会不同，promoteCall方法
private <T> void finished(Deque<T> calls, T call, boolean promoteCalls) {
int runningCallsCount;
Runnable idleCallback;
synchronized (this) {
//TODO calls 移除队列
if (!calls.remove(call)) throw new AssertionError("Call wasn't in-flight!");
//TODO 检查是否为异步请求，检查等候的队列 readyAsyncCalls，如果存在等候队列，则将等候队列加入执行队列
if (promoteCalls) promoteCalls();
//TODO 运行队列的数量
runningCallsCount = runningCallsCount();
idleCallback = this.idleCallback;
}
//闲置调用
if (runningCallsCount == 0 && idleCallback != null) {
idleCallback.run();
}
}
private void promoteCalls() {
//TODO 检查 运行队列 与 等待队列
if (runningAsyncCalls.size() >= maxRequests) return; // Already running max capacity.
if (readyAsyncCalls.isEmpty()) return; // No ready calls to promote.
//TODO 将等待队列加入到运行队列中
for (Iterator<AsyncCall> i = readyAsyncCalls.iterator(); i.hasNext(); ) {
AsyncCall call = i.next();
//TODO 相同host的请求没有达到最大，加入运行队列
if (runningCallsForHost(call) < maxRequestsPerHost) {
i.remove();
runningAsyncCalls.add(call);
executorService().execute(call);
}
if (runningAsyncCalls.size() >= maxRequests) return; // Reached max capacity.
}
}
B执行Enqueue
// RealCall.java
@Override public void enqueue(Callback responseCallback) {
synchronized (this) { // 如果这个 call 已经被执行过，抛异常
if (executed) throw new IllegalStateException("Already Executed");
executed = true;
}
captureCallStackTrace();
eventListener.callStart(this);
client.dispatcher().enqueue(new AsyncCall(responseCallback));
}
//TODO 执行异步请求
synchronized void enqueue(AsyncCall call) {
//TODO 同时请求不能超过并发数(64,可配置调度器调整)
//TODO okhttp会使用共享主机即 地址相同的会共享socket
//TODO 同一个host最多允许5条线程通知执行请求
if (runningAsyncCalls.size() < maxRequests &&
runningCallsForHost(call) < maxRequestsPerHost) {
//TODO 加入运行队列 并交给线程池执行
runningAsyncCalls.add(call);
//TODO AsyncCall 是一个runnable，放到线程池中去执行，查看其execute实现
executorService().execute(call);
} else {
//TODO 加入等候队列
readyAsyncCalls.add(call);
}
}
