okHttp源码分析(1)-分发器

作者: yosen | 来源:发表于2019-11-20 16:29 被阅读0次

一. okHttp简介

okhttp已经成为Android开发中必不可少的网络请求工具，无论在平时开发还是面试的过程中，都会有所涉及，弄清okhttp的使用流程，已经是每一个android开发者成为高级工程师的必经之路。其实其原理并不复杂，本文将分两篇来着重介绍okhttp中分发器和拦截器原理。

二. 大纲

okHttp的优点以及请求过程

Dispatcher的分发流程

三. okHttp的优点以及请求过程

首先我们来看看使用okhttp都有哪些优点：

支持HTTP/2并允许对同一主机的所有请求共享一个套接字
通过连接池，复用socket，减少请求延迟
默认通过gzip压缩数据
响应缓存，避免重复请求网络
请求失败自动重试主机其它ip，自动重定向

okHttp的请求流程

使用okhttp的大致流程为：

创建一个OkHttpClient
创建一个Request对象
创建一个call对象，接受request
进行请求执行任务
内部通过Dispatcher分发任务
五大默认拦截器完成整个请求过程
返回结果

什么是分发器Dispatcher

Dispatcher，分发器就是来调配请求任务的，内部会包含一个线程池。可以在创建OkHttpClient`时，传递我们自己定义的线程池来创建分发器。

这个Dispatcher中的成员有:

//异步请求同时存在的最大请求
private int maxRequests = 64;
//异步请求同一域名同时存在的最大请求
private int maxRequestsPerHost = 5;
//闲置任务(没有请求时可执行一些任务，由使用者设置)
private @Nullable Runnable idleCallback;

//异步请求使用的线程池
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<>();

get，post请求流程

get请求流程：

//1.创建OkHttpClient对象
OkHttpClient okHttpClient = new OkHttpClient();
//2.创建Request对象，设置请求方式。
Request request = new Request.Builder()
        .url("https://www.jianshu.com/u/f260c485f077")
        .get()
        .build();
//3.创建一个call对象
Call call = okHttpClient.newCall(request);
//4.同步请求
new Thread(new Runnable() {
    @Override
    public void run() {
        
        Response response = call.execute();
       
     }}).start();
//5.异步请求
call.enqueue(new Callback() {
    //请求失败执行的方法
    @Override
    public void onFailure(Call call, IOException e) {
        String err = e.getMessage().toString();
    }

    //请求成功执行的方法
    @Override
    public void onResponse(Call call, Response response) throws IOException {
        inal String rtn = response.body().string();
    }
});

post请求流程：

//1.创建OkHttpClient对象,设置参数
OkHttpClient okHttpClient = new OkHttpClient();

FormBody.Builder mBuild = new FormBody.Builder();
mBuild.add("key1", "vaule1")
        .add("key2", "vaule2");
RequestBody requestBodyPost = mBuild.build();

//2.创建Request对象，设置请求方式。
Request request = new Request.Builder()
        .url("http://www.baidu.com")
        .post(requestBodyPost)
        .build();
//3.创建一个call对象
Call call = okHttpClient.newCall(request);
//4.请求回调方法
call.enqueue(new Callback() {
    @Override
    public void onFailure(Call call, IOException e) {

    }

    //请求成功执行的方法
    @Override
    public void onResponse(Call call, Response response) throws IOException {

    }
});

四. Dispatcher的分发流程

okHttp中Dispatcher的分发流程大致分为以下几步:

调用execute或者enqueue加入任务
Dispatcher根据条件判断将当前任务加入队列 runningAsyncCalls(执行队列)还是readyAsyncCalls(等待队列)
runningAsyncCalls队列调用线程池执行任务，
runningAsyncCalls执行任务完成，根据条件获取readyAsyncCalls中任务执行

根据okhttp中Dispatcher的分发流程，我们有几个问题需要弄清楚：

Q: Dispatcher将请求分发到队列过程中，如何决定放入ready还是running？

Q: 从ready移动running的条件是什么？（如何移动，从哪里移动）

Q: Dispatcher分发器线程池的工作行为是怎样的。

带着以上三个问题，我们可以看看源码是如何实现的。

第一个问题 Dispatcher将请求分发到队列过程中，如何决定放入ready还是running

当我们要执行一个异步请求的时候，会调用okhttp的enqueue方法，其内部就会调用分发器的enqueue方法，我们直接来看分发器的enqueue方法做了什么：

okhttp的enqueue方法：

@Override 
public void enqueue(Callback responseCallback) {
    synchronized (this) {
      if (executed) throw new IllegalStateException("Already Executed");
      executed = true;
    }
    captureCallStackTrace();
    // client就是OkHttpClient 通过client获取Dispatcher 调用Dispatcher的enqueue
    client.dispatcher().enqueue(new AsyncCall(responseCallback));
  }

Dispatcher的enqueue方法：

private int maxRequests = 64;
private int maxRequestsPerHost = 5;

synchronized void enqueue(AsyncCall call) {
    //runningAsyncCalls.size() < maxRequests(最大正在请求的数量)
    //runningCallsForHost(call) < maxRequestsPerHost（同一域名最大正在请求的个数限制）
if (runningAsyncCalls.size() < maxRequests && runningCallsForHost(call) <                      maxRequestsPerHost) {
        runningAsyncCalls.add(call);
        executorService().execute(call);
    } else {
        readyAsyncCalls.add(call);
    }
  }

看到这里相信大家都能明白第一个问题，由注解可以看到，Dispatcher将任务加入队列的两个条件，当前最大请求数不超过64，同一域名最大正在请求的个数限制不超过5，同时满足这两个的情况下，想请求加入执行队列runningAsyncCalls中，并立即执行。不满足条件加入等待队列readyAsyncCalls中。

第二个问题从ready移动running的条件是什么？（如何移动，从哪里移动）

然后我们再回过头来看看AsyncCall是个什么，我们的请求加入这个AsyncCall以后都做了什么，打开AsyncCal源码

RealCall implements Call

首先可以看到RealCall implements Call ，当我们调用call.enqueue时，也就是再调用RealCall.enqueue,那么我们只要看RealCall.enqueue中做了什么即可。

@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 {
            responseCallback.onFailure(RealCall.this, e);
        }
    } finally {
        //请求执行完毕，调用finish();
        client.dispatcher().finished(this);
    }
}

如何把ready移动running，那么肯定是running中任务已经执行完成，所以我们继续看finnally中 client.dispatcher().finished(this);做了什么。

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

private void promoteCalls() {
    //判断正在执行的队列个数，不满足返回
    if (runningAsyncCalls.size() >= maxRequests) return; // Already running max capacity.
   //判断等待队列是否有请求，不满足返回
    if (readyAsyncCalls.isEmpty()) return; // No ready calls to promote.
    //循环获取等待队列中的请求
    for (Iterator<RealCall.AsyncCall> i = readyAsyncCalls.iterator(); i.hasNext(); ) {
        RealCall.AsyncCall call = i.next();
        //判断当前call的host执行个数是否小于maxRequestsPerHost
        if (runningCallsForHost(call) < maxRequestsPerHost) {
            i.remove();
            //将等待队列中的call加入到runningAsyncCalls
            runningAsyncCalls.add(call);
            //开始执行任务
            executorService().execute(call);
        }
        //判断正在执行的队列个数，满足就returen，不在继续增加
        if (runningAsyncCalls.size() >= maxRequests) return; // Reached max capacity.
    }
}

以上代码逻辑，注释的很清晰。会通过相同的条件，将等待队列中的请求加入到执行队列

最后一个问题，分发器线程池的工作行为是怎样的。

看到这里，相信大家已经对okhtt的分发流程了解个大概，此时我们已经将请求加入到了队列中，而在分发执行请求的过程中，okhttp是怎么来执行这些任务的呢，还是继续来看源码，通过以上源码的分析我们可以看到Dispatcher是通过executorService().execute(call)方法执行任务，所以我们直接看executorService()方法的源码

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

在OkHttp的分发器中的线程池定义如上，其实就和Executors.newCachedThreadPool()创建的线程一样。首先核心线程为0，表示线程池不会一直为我们缓存线程，线程池中所有线程都是在60s内没有工作就会被回收。而最大线程Integer.MAX_VALUE与等待队列SynchronousQueue的组合能够得到最大的吞吐量。即当需要线程池执行任务时，如果不存在空闲线程不需要等待，马上新建线程执行任务！等待队列的不同指定了线程池的不同排队机制。一般来说，等待队列BlockingQueue有：ArrayBlockingQueue、LinkedBlockingQueue与SynchronousQueue。

假设向线程池提交任务时，核心线程都被占用的情况下：

ArrayBlockingQueue：基于数组的阻塞队列，初始化需要指定固定大小。

当使用此队列时，向线程池提交任务，会首先加入到等待队列中，当等待队列满了之后，再次提交任务，尝试加入队列就会失败，这时就会检查如果当前线程池中的线程数未达到最大线程，则会新建线程执行新提交的任务。所以最终可能出现后提交的任务先执行，而先提交的任务一直在等待。

LinkedBlockingQueue：基于链表实现的阻塞队列，初始化可以指定大小，也可以不指定。

当指定大小后，行为就和ArrayBlockingQueu一致。而如果未指定大小，则会使用默认的Integer.MAX_VALUE作为队列大小。这时候就会出现线程池的最大线程数参数无用，因为无论如何，向线程池提交任务加入等待队列都会成功。最终意味着所有任务都是在核心线程执行。如果核心线程一直被占，那就一直等待。

SynchronousQueue : 无容量的队列。

使用此队列意味着希望获得最大并发量。因为无论如何，向线程池提交任务，往队列提交任务都会失败。而失败后如果没有空闲的非核心线程，就会检查如果当前线程池中的线程数未达到最大线程，则会新建线程执行新提交的任务。完全没有任何等待，唯一制约它的就是最大线程数的个数。因此一般配合Integer.MAX_VALUE就实现了真正的无等待。

但是需要注意的时，我们都知道，进程的内存是存在限制的，而每一个线程都需要分配一定的内存。所以线程并不能无限个数。那么当设置最大线程数为Integer.MAX_VALUE时，OkHttp同时还有最大请求任务执行个数: 64的限制。这样即解决了这个问题同时也能获得最大吞吐。

分发器的流程以及原理就到这里，okhttp每个版本代码可能会略有不同，本文基于okhttp3.6.0源码进行分析。下一篇我们将介绍okhttp中的拦截器是如何实现的。

okHttp源码分析(1)-分发器

一. okHttp简介

二. 大纲

三. okHttp的优点以及请求过程

四. Dispatcher的分发流程

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读