OkHttp 3(1)

• 如果用户使用单线程 + 同步任务请求，那么同时活跃的任务数肯定只有单个，没必要控制。

• 如果用户使用多线程或者线程池 + 同步请求的话，那相当于用户自己定制和实现了异步请求策略，那么对于异步请求的管理肯定交给用户是最合适的，OkHttp也很难去管理用户的自定义实现。

• 用户可以通过配置OkHttpClient来修改dispatcher的属性，从而扩展异步请求的策略。

Dispatcher的ExecutorService默认实现

==============================

在了解异步任务的执行流程之前，我们先来简单了解一下Dispatcher用来执行异步任务的默认线程池。

代码1：

public synchronized ExecutorService executorService() {

if (executorService == null) {

//0：表示没有核心线程，也就是没有常驻线程。

//Integer.MAX_VALUE：表示活跃线程等同于最大整数，活跃线程不会常驻，有最大空闲存活时间限制。

//60和TimeUnit.SECONDS：活跃线程的最大空闲存活时间是60秒

//new SynchronousQueue<>()：同步阻塞队列（大家可以网上找一下这方面资料了解一下），这个队列不存在容器属性，如果消费不及时，生成端put动作会被阻塞。
在这里的效果就是，如果调用了ExecutorService.execute()后，如果没有空闲线程或者还没来得及创建线程，那么execute()会被阻塞，直到有线程来消费。

//Util.threadFactory(“OkHttp Dispatcher”, false)：线程工程，创建的线程添加名称前缀OkHttp Dispatcher;创建的线程为守护线程。

//第六个参数

executorService = new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60, TimeUnit.SECONDS,

new SynchronousQueue<>(), Util.threadFactory(“OkHttp Dispatcher”, false));

}

return executorService;

}

总结重要的三点：

• 线程池几乎不限制线程数。

• 线程默认空闲存活60秒。

• ExecutorService.execute()方法调用时，如果没有线程及时消费会一直阻塞。

Dispatcher异步任务调度策略

==================

异步任务的执行策略的大概流程：

从上面可以看出涉及Dispatcher的两个关键方法：enqueue(AsyncCall)和promoteAndExecute()。下面就分别来分析这两个方法。

方法：enqueue(AsyncCall)

enqueue方法还没有对AsyncCall进行真正的资源分配和调度，只是对AsyncCall进行一些设置，真正的调度逻辑是由后面的promoteAndExecute()方法实现。

我们先来简单看一下enqueue方法的流程：

接着我们分析一下代码：

void enqueue(AsyncCall call) {

synchronized (this) {

//第一步:添加AsyncCall到预执行队列

readyAsyncCalls.add(call);

//第二步

if (!call.get().forWebSocket) {

AsyncCall existingCall = findExistingCallWithHost(call.host());

if (existingCall != null) call.reuseCallsPerHostFrom(existingCall);

}

}

//第三步

promoteAndExecute();

}

这方法就三部分，我相信第1、3步大家都是一眼就看穿了，所以就只分析一下第二步，其代码逻辑是设置同一Host的连接计数器：

2.1 同一Host的连接计数器主要是和maxRequestsPerHost属性做比较，目的是控制对同一Host服务器的连接数。

2.2 通过让具有相同Host的AsyncCall对象都共用一个计数器来实现。通过synchronized锁保证同一时间进入代码块的只有一个AsyncCall对象。

• 通过synchronized锁保证同一时间进入代码块的只有一个AsyncCall对象。

• 调用findExistingCallWithHost(call.host())方法：查找是否已经存在至少一个相同Host的AsyncCall对象，并且返回任意一个。

@Nullable

private AsyncCall findExistingCallWithHost(String host) {

for (AsyncCall existingCall : runningAsyncCalls) {

if (existingCall.host().equals(host)) return existingCall;

}

for (AsyncCall existingCall : readyAsyncCalls) {

if (existingCall.host().equals(host)) return existingCall;

}

return null;

}

final class AsyncCall extends NamedRunnable {

private final Callback responseCallback;

//同一Host的连接计数器

private volatile AtomicInteger callsPerHost = new AtomicInteger(0);

…

//设置计数器

void reuseCallsPerHostFrom(AsyncCall other) {

this.callsPerHost = other.callsPerHost;

}

…

方法：promoteAndExecute()

promoteAndExecute()负责真正对AsyncCall进行资源的调度。

和上面一样，我们还是先来看一下简单的流程：

接着我们在解析一下代码：

private boolean promoteAndExecute() {

assert (!Thread.holdsLock(this));

//创建空的可执行AsyncCall集合

List executableCalls = new ArrayList<>();

boolean isRunning;

//锁保护

synchronized (this) {

//对预执行队列进行迭代循环

for (Iterator i = readyAsyncCalls.iterator(); i.hasNext(); ) {

AsyncCall asyncCall = i.next();

//正在执行的队列size是否已经>=maxRequests，如果是跳出迭代循环。

if (runningAsyncCalls.size() >= maxRequests，) break;

//判断同一Host的连接计数器的值是否>=maxRequestsPerHost，如果是跳出迭代循环。

if (asyncCall.callsPerHost().get() >= maxRequestsPerHost，) continue;

//从迭代器弹出，也就是从readyAsyncCalls删除了。

i.remove();

//同一Host的连接计数器自增1

asyncCall.callsPerHost().incrementAndGet();

//添加到可执行集合。

executableCalls.add(asyncCall);

//添加到正在执行队列，也就是这时候asyncCall对象已经是被当作执行中状态的了。

runningAsyncCalls.add(asyncCall);

}

isRunning = runningCallsCount() > 0;

}

//遍历可执行集合

for (int i = 0, size = executableCalls.size(); i < size; i++) {

AsyncCall asyncCall = executableCalls.get(i);

//调用asyncCall.executeOn方法。

asyncCall.executeOn(executorService());

}

return isRunning;

}

代码的重要步骤的解析我都加在上面注释里面了，相信也不难看懂。

但是最后还是要简单介绍一下“asyncCall.executeOn(executorService())”调用的执行逻辑。其实异步任务在线程资源层面的策略，是有OkHttpClient、Dispatcher和Call之间相互协作完成的，所以你单单只看Dispatcher的代码，你可能有点难以勾勒出一个相对清晰和完整的功能流程。

asyncCall.executeOn(executorService())执行流程

在开始理解AsyncCall#executeOn(ExecutorService)执行流程之前，先简单了解AsyncCall的一些基本性质：

• AsyncCall是NamedRunnable的子类，NamedRunnable实现了Runnable接口，因此AsyncCall对象可以直接作为参数让方法“ExecutorService#execute(Runnable)”执行。

• NamedRunnable实现了run()方法，run()方法的具体任务逻辑委派给子类execute()方法，因此“executorService#execute(Runnable)”主要执行的是AsyncCall的execute()方法。

下面我们来看两个具体的代码片段：

void executeOn(ExecutorService executorService) {

assert (!Thread.holdsLock(client.dispatcher()));

boolean success = false;

try {

//Call任务被线程池执行

executorService.execute(this);

success = true;

} catch (RejectedExecutionException e) {

…

} finally {

if (!success) {

//重点是这里

client.dispatcher().finished(this);

}

}

}

@Override

protected void execute() {

boolean signalledCallback = false;

transmitter.timeoutEnter();

try {

Response response = getResponseWithInterceptorChain();

…

} catch (IOException e) {

…

} catch (Throwable t) {

…

} finally {

//其他都不看，先看这

client.dispatcher().finished(this);

}

}

因此接着上面Call.executeOn的流程继续画：

Dispatcher#finished(AsyncCall)功能：

• 同一host连接计数器递减1。

• 把当前asyncCall对象移出正在执行队列（runningAsyncCalls）。其实到这一步当前的AsyncCall对象的使命就已经完全结束了，后面是Dispatcher自身循环调用的逻辑。

• 再次调用promoteAndExecute()，从预执行任务队列中拉取任务执行。

• 如果预执行任务队列已经为空，调用线程空闲回调。

结尾

我还总结出了互联网公司Android程序员面试涉及到的绝大部分面试题及答案，并整理做成了文档，以及系统的进阶学习视频资料分享给大家。
（包括Java在Android开发中应用、APP框架知识体系、高级UI、全方位性能调优，NDK开发，音视频技术，人工智能技术，跨平台技术等技术资料），希望能帮助到你面试前的复习，且找到一个好的工作，也节省大家在网上搜索资料的时间来学习。

《Android学习笔记总结+移动架构视频+大厂面试真题+项目实战源码》，点击传送门，即可获取！

• 再次调用promoteAndExecute()，从预执行任务队列中拉取任务执行。

• 如果预执行任务队列已经为空，调用线程空闲回调。

结尾

我还总结出了互联网公司Android程序员面试涉及到的绝大部分面试题及答案，并整理做成了文档，以及系统的进阶学习视频资料分享给大家。
（包括Java在Android开发中应用、APP框架知识体系、高级UI、全方位性能调优，NDK开发，音视频技术，人工智能技术，跨平台技术等技术资料），希望能帮助到你面试前的复习，且找到一个好的工作，也节省大家在网上搜索资料的时间来学习。

[外链图片转存中…(img-DmQq8wwB-1715727428833)]
《Android学习笔记总结+移动架构视频+大厂面试真题+项目实战源码》，点击传送门，即可获取！