Android 扩展OkHttp支持请求优先级调度

最新推荐文章于 2024-07-02 14:04:59 发布

shotaSu

最新推荐文章于 2024-07-02 14:04:59 发布

阅读量1.1k

点赞数

分类专栏：网络编程

网络编程专栏收录该内容

3 篇文章

订阅专栏

本文介绍如何为OkHttp添加请求优先级调度功能，通过自定义请求优先级并修改OkHttp源码实现请求按优先级执行。

在当今这个App泛滥的时代，网络请求几乎是每一个App必不可少的一部分，请求几乎遍布App的每一个界面中。我们进入A界面后，App发起了一系列请求，这时候假如还有一部分请求没有被执行，我们就进入B界面开始新的网络请求，这时候原来A界面的网络请求我们有两个选择：

取消A界面的所有未开始执行的网络请求
不取消A界面的所有网络请求，但是B界面的请求要优先于A界面的请求执行，B界面的网络请求执行完毕后再去执行A界面未执行完毕的请求。

对于第一种情况，我们很好做到，在Activity的onDestroy回调中取消该界面中所有请求，这里需要明确一点，本篇文章的网络层是OkHttp，既然选择了OkHttp，如果要在onDestroy中取消未开始执行以及已经开始执行的网络请求，就必须给每一个请求设置一个tag，然后通过该tag来需要网络请求。比较明智的做法是以该Activity的上下文的hash值作为tag。取消请求时将hash值传入，则该界面所有的请求都可以取消。

但是实际情况并非如此，有一部分网络请求我们不想取消它，仍然想要进行请求，因为这部分的请求比较重要，需要拉到客户端进行使用，取消这个请求可能会带来不必要的麻烦，因此，我们需要保留这些请求。但是我们进入了一个新的界面，新界面的网络优先级比较高，应该先被执行，这就是第二种情况。

每种情况有对应的解决方法，第一种情况显得比较简单，我们先来实现它。

<code class="hljs avrasm has-numbering">public class MainActivity extends AppCompatActivity implements View<span class="hljs-preprocessor">.OnClickListener</span> {
    private Button btn1<span class="hljs-comment">;</span>
    private Button btn2<span class="hljs-comment">;</span>
    private OkHttpClient mOkHttpClient<span class="hljs-comment">;</span>
    @Override

    protected void onCreate(Bundle savedInstanceState) {
        super<span class="hljs-preprocessor">.onCreate</span>(savedInstanceState)<span class="hljs-comment">;</span>
        setContentView(R<span class="hljs-preprocessor">.layout</span><span class="hljs-preprocessor">.activity</span>_main)<span class="hljs-comment">;</span>
        btn1 = (Button) findViewById(R<span class="hljs-preprocessor">.id</span><span class="hljs-preprocessor">.btn</span>1)<span class="hljs-comment">;</span>
        btn2 = (Button) findViewById(R<span class="hljs-preprocessor">.id</span><span class="hljs-preprocessor">.btn</span>2)<span class="hljs-comment">;</span>
        btn1<span class="hljs-preprocessor">.setOnClickListener</span>(this)<span class="hljs-comment">;</span>
        btn2<span class="hljs-preprocessor">.setOnClickListener</span>(this)<span class="hljs-comment">;</span>
        mOkHttpClient = new OkHttpClient()<span class="hljs-comment">;</span>
    }
    @Override
    protected void onDestroy() {
        super<span class="hljs-preprocessor">.onDestroy</span>()<span class="hljs-comment">;</span>
        Log<span class="hljs-preprocessor">.e</span>(<span class="hljs-string">"TAG"</span>, <span class="hljs-string">"onDestroy"</span>)<span class="hljs-comment">;</span>
        cancelByTag(this<span class="hljs-preprocessor">.hashCode</span>())<span class="hljs-comment">;</span>
    }
    @Override
    public void onClick(View v) {
        switch (v<span class="hljs-preprocessor">.getId</span>()) {
            case R<span class="hljs-preprocessor">.id</span><span class="hljs-preprocessor">.btn</span>1:
                sendRequest()<span class="hljs-comment">;</span>
                <span class="hljs-keyword">break</span><span class="hljs-comment">;</span>
            case R<span class="hljs-preprocessor">.id</span><span class="hljs-preprocessor">.btn</span>2:
                startActivity(new Intent(this, SecondActivity<span class="hljs-preprocessor">.class</span>))<span class="hljs-comment">;</span>
                finish()<span class="hljs-comment">;</span>
                <span class="hljs-keyword">break</span><span class="hljs-comment">;</span>
        }
    }

    private void sendRequest() {
        Request<span class="hljs-preprocessor">.Builder</span> builder = new Request<span class="hljs-preprocessor">.Builder</span>()<span class="hljs-comment">;</span>

 builder<span class="hljs-preprocessor">.url</span>(<span class="hljs-string">"https://www.baidu.com"</span>)<span class="hljs-preprocessor">.tag</span>(this<span class="hljs-preprocessor">.hashCode</span>())<span class="hljs-comment">;</span>



        Request request1 = builder<span class="hljs-preprocessor">.build</span>()<span class="hljs-comment">;</span>
        Request request2 = builder<span class="hljs-preprocessor">.build</span>()<span class="hljs-comment">;</span>
        Request request3 = builder<span class="hljs-preprocessor">.build</span>()<span class="hljs-comment">;</span>
        Request request4 = builder<span class="hljs-preprocessor">.build</span>()<span class="hljs-comment">;</span>
        Request request5 = builder<span class="hljs-preprocessor">.build</span>()<span class="hljs-comment">;</span>
        Request request6 = builder<span class="hljs-preprocessor">.build</span>()<span class="hljs-comment">;</span>
        Request request7 = builder<span class="hljs-preprocessor">.build</span>()<span class="hljs-comment">;</span>
        Request request8 = builder<span class="hljs-preprocessor">.build</span>()<span class="hljs-comment">;</span>
        Request request9 = builder<span class="hljs-preprocessor">.build</span>()<span class="hljs-comment">;</span>
        Request request10 = builder<span class="hljs-preprocessor">.build</span>()<span class="hljs-comment">;</span>


        final <span class="hljs-keyword">Call</span> call1 = mOkHttpClient<span class="hljs-preprocessor">.newCall</span>(request1)<span class="hljs-comment">;</span>
        final <span class="hljs-keyword">Call</span> call2 = mOkHttpClient<span class="hljs-preprocessor">.newCall</span>(request2)<span class="hljs-comment">;</span>
        final <span class="hljs-keyword">Call</span> call3 = mOkHttpClient<span class="hljs-preprocessor">.newCall</span>(request3)<span class="hljs-comment">;</span>
        final <span class="hljs-keyword">Call</span> call4 = mOkHttpClient<span class="hljs-preprocessor">.newCall</span>(request4)<span class="hljs-comment">;</span>
        final <span class="hljs-keyword">Call</span> call5 = mOkHttpClient<span class="hljs-preprocessor">.newCall</span>(request5)<span class="hljs-comment">;</span>
        final <span class="hljs-keyword">Call</span> call6 = mOkHttpClient<span class="hljs-preprocessor">.newCall</span>(request6)<span class="hljs-comment">;</span>
        final <span class="hljs-keyword">Call</span> call7 = mOkHttpClient<span class="hljs-preprocessor">.newCall</span>(request7)<span class="hljs-comment">;</span>
        final <span class="hljs-keyword">Call</span> call8 = mOkHttpClient<span class="hljs-preprocessor">.newCall</span>(request8)<span class="hljs-comment">;</span>
        final <span class="hljs-keyword">Call</span> call9 = mOkHttpClient<span class="hljs-preprocessor">.newCall</span>(request9)<span class="hljs-comment">;</span>
        final <span class="hljs-keyword">Call</span> call10 = mOkHttpClient<span class="hljs-preprocessor">.newCall</span>(request10)<span class="hljs-comment">;</span>

        final Callback callback = new Callback() {
            @Override
            public void onFailure(<span class="hljs-keyword">Call</span> <span class="hljs-keyword">call</span>, IOException e) {
                Log<span class="hljs-preprocessor">.e</span>(<span class="hljs-string">"TAG"</span>, <span class="hljs-string">"failure. isCanceled:"</span> + <span class="hljs-keyword">call</span><span class="hljs-preprocessor">.isCanceled</span>() + <span class="hljs-string">" isExecuted:"</span> + <span class="hljs-keyword">call</span><span class="hljs-preprocessor">.isExecuted</span>())<span class="hljs-comment">;</span>
            }

            @Override
            public void onResponse(<span class="hljs-keyword">Call</span> <span class="hljs-keyword">call</span>, Response response) throws IOException {
                Log<span class="hljs-preprocessor">.e</span>(<span class="hljs-string">"TAG"</span>, <span class="hljs-string">"success. isCanceled:"</span> + <span class="hljs-keyword">call</span><span class="hljs-preprocessor">.isCanceled</span>() + <span class="hljs-string">" isExecuted:"</span> + <span class="hljs-keyword">call</span><span class="hljs-preprocessor">.isExecuted</span>())<span class="hljs-comment">;</span>
            }
        }<span class="hljs-comment">;</span>

        call1<span class="hljs-preprocessor">.enqueue</span>(callback)<span class="hljs-comment">;</span>
        call2<span class="hljs-preprocessor">.enqueue</span>(callback)<span class="hljs-comment">;</span>
        call3<span class="hljs-preprocessor">.enqueue</span>(callback)<span class="hljs-comment">;</span>
        call4<span class="hljs-preprocessor">.enqueue</span>(callback)<span class="hljs-comment">;</span>
        call5<span class="hljs-preprocessor">.enqueue</span>(callback)<span class="hljs-comment">;</span>
        call6<span class="hljs-preprocessor">.enqueue</span>(callback)<span class="hljs-comment">;</span>
        call7<span class="hljs-preprocessor">.enqueue</span>(callback)<span class="hljs-comment">;</span>
        call8<span class="hljs-preprocessor">.enqueue</span>(callback)<span class="hljs-comment">;</span>
        call9<span class="hljs-preprocessor">.enqueue</span>(callback)<span class="hljs-comment">;</span>
        call10<span class="hljs-preprocessor">.enqueue</span>(callback)<span class="hljs-comment">;</span>

    }

    public void cancelByTag(Object tag) {
        for (<span class="hljs-keyword">Call</span> <span class="hljs-keyword">call</span> : mOkHttpClient<span class="hljs-preprocessor">.dispatcher</span>()<span class="hljs-preprocessor">.queuedCalls</span>()) {
            if (tag<span class="hljs-preprocessor">.equals</span>(<span class="hljs-keyword">call</span><span class="hljs-preprocessor">.request</span>()<span class="hljs-preprocessor">.tag</span>())) {
                <span class="hljs-keyword">call</span><span class="hljs-preprocessor">.cancel</span>()<span class="hljs-comment">;</span>
            }
        }

        for (<span class="hljs-keyword">Call</span> <span class="hljs-keyword">call</span> : mOkHttpClient<span class="hljs-preprocessor">.dispatcher</span>()<span class="hljs-preprocessor">.runningCalls</span>()) {
            if (tag<span class="hljs-preprocessor">.equals</span>(<span class="hljs-keyword">call</span><span class="hljs-preprocessor">.request</span>()<span class="hljs-preprocessor">.tag</span>())) {
                <span class="hljs-keyword">call</span><span class="hljs-preprocessor">.cancel</span>()<span class="hljs-comment">;</span>
            }
        }
    }
}</code>

当我们点击发送请求的按钮之后，所有请求都被设置了一个tag后发送出去，然后我们需要快速的点击跳转按钮，让当前页面finish掉，之后就会回调onDestroy方法，onDestyoy方法中我们调用了取消请求的方法，如果还有请求没有开始执行，该请求就会被取消掉。这样，第一种情况就简单的实现了下。

在实现第二种情况的时候，我们需要知道一个概念，就是一个集合中如何对元素进行排序，通常，有两种做法。

将待比较的类实现Comparable接口，调用Collections.sort(list)方法进行排序
新建一个类实现Comparator接口，调用Collections.sort(list,comparator)方法进行排序

假如现在我们有一个类叫Person，它有两个属性，name和age，我们有一个List，里面都是Person，我们希望对这个List进行排序，并且排序的原则是根据age从小到大排序。按照实现Comparable接口的方法，我们需要将Person实现该接口，就像这样子。

<code class="hljs cs has-numbering"><span class="hljs-keyword">public</span> <span class="hljs-keyword">class</span> Person implements Comparable<Person>{
    <span class="hljs-keyword">private</span> String name;
    <span class="hljs-keyword">private</span> <span class="hljs-keyword">int</span> age;

    <span class="hljs-keyword">public</span> <span class="hljs-title">Person</span>(String name, <span class="hljs-keyword">int</span> age) {
        <span class="hljs-keyword">this</span>.name = name;
        <span class="hljs-keyword">this</span>.age = age;
    }
    <span class="hljs-keyword">public</span> String <span class="hljs-title">getName</span>() {
        <span class="hljs-keyword">return</span> name;
    }
    <span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title">setName</span>(String name) {
        <span class="hljs-keyword">this</span>.name = name;
    }
    <span class="hljs-keyword">public</span> <span class="hljs-keyword">int</span> <span class="hljs-title">getAge</span>() {
        <span class="hljs-keyword">return</span> age;
    }
    <span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title">setAge</span>(<span class="hljs-keyword">int</span> age) {
        <span class="hljs-keyword">this</span>.age = age;
    }
    @Override
    <span class="hljs-keyword">public</span> String <span class="hljs-title">toString</span>() {
        <span class="hljs-keyword">return</span> <span class="hljs-string">"Person{"</span> +
                <span class="hljs-string">"name='"</span> + name + <span class="hljs-string">'\''</span> +
                <span class="hljs-string">", age="</span> + age +
                <span class="hljs-string">'}'</span>;
    }
    @Override
    <span class="hljs-keyword">public</span> <span class="hljs-keyword">int</span> <span class="hljs-title">compareTo</span>(Person another) {
        <span class="hljs-keyword">return</span> <span class="hljs-keyword">this</span>.age-another.age;
    }
}</code>

这时候我们生成一个都是Person实例的List，调用sort方法进行排序看下结果如何

<code class="hljs cs has-numbering">Person p1=<span class="hljs-keyword">new</span> Person(<span class="hljs-string">"张三"</span>,<span class="hljs-number">23</span>);
Person p2=<span class="hljs-keyword">new</span> Person(<span class="hljs-string">"李四"</span>,<span class="hljs-number">12</span>);
Person p3=<span class="hljs-keyword">new</span> Person(<span class="hljs-string">"王五"</span>,<span class="hljs-number">21</span>);
Person p4=<span class="hljs-keyword">new</span> Person(<span class="hljs-string">"赵六"</span>,<span class="hljs-number">8</span>);
Person p5=<span class="hljs-keyword">new</span> Person(<span class="hljs-string">"钱七"</span>,<span class="hljs-number">40</span>);
List<Person> persons = Arrays.asList(p1, p2, p3, p4, p5);
System.<span class="hljs-keyword">out</span>.println(persons);
Collections.sort(persons);
System.<span class="hljs-keyword">out</span>.println(persons);</code>

输出结果如下

[Person{name=’张三’, age=23}, Person{name=’李四’, age=12}, Person{name=’王五’, age=21}, Person{name=’赵六’, age=8}, Person{name=’钱七’, age=40}]
[Person{name=’赵六’, age=8}, Person{name=’李四’, age=12}, Person{name=’王五’, age=21}, Person{name=’张三’, age=23}, Person{name=’钱七’, age=40}]

可以看到按age进行排序，并且从小到大的排了顺序，那么如果要从大到小排序呢，很简单，修改compareTo方法即可

<code class="hljs java has-numbering"><span class="hljs-annotation"></span></code><pre name="code" class="prettyprint"><code class="hljs java has-numbering"><span class="hljs-annotation">@Override</span>
<span class="hljs-keyword">public</span> <span class="hljs-keyword">int</span> <span class="hljs-title">compareTo</span>(Person another) {
    <span class="hljs-keyword">return</span> another.age-<span class="hljs-keyword">this</span>.age;
}</code>

如果实现Comparator接口，那么我们无需改动Person类，最原始的Person类如下

<code class="hljs cs has-numbering"><span class="hljs-keyword">public</span> <span class="hljs-keyword">class</span> Person{
    <span class="hljs-keyword">private</span> String name;
    <span class="hljs-keyword">private</span> <span class="hljs-keyword">int</span> age;

    <span class="hljs-keyword">public</span> <span class="hljs-title">Person</span>(String name, <span class="hljs-keyword">int</span> age) {
        <span class="hljs-keyword">this</span>.name = name;
        <span class="hljs-keyword">this</span>.age = age;
    }

    <span class="hljs-keyword">public</span> String <span class="hljs-title">getName</span>() {
        <span class="hljs-keyword">return</span> name;
    }

    <span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title">setName</span>(String name) {
        <span class="hljs-keyword">this</span>.name = name;
    }

    <span class="hljs-keyword">public</span> <span class="hljs-keyword">int</span> <span class="hljs-title">getAge</span>() {
        <span class="hljs-keyword">return</span> age;
    }

    <span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title">setAge</span>(<span class="hljs-keyword">int</span> age) {
        <span class="hljs-keyword">this</span>.age = age;
    }
    @Override
    <span class="hljs-keyword">public</span> String <span class="hljs-title">toString</span>() {
        <span class="hljs-keyword">return</span> <span class="hljs-string">"Person{"</span> +
                <span class="hljs-string">"name='"</span> + name + <span class="hljs-string">'\''</span> +
                <span class="hljs-string">", age="</span> + age +
                <span class="hljs-string">'}'</span>;
    }
}</code>

取而代之的方法便是新建一个类实现Comparator接口

<code class="hljs axapta has-numbering"><span class="hljs-keyword">public</span> <span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">PersonComparator</span> <span class="hljs-inheritance"><span class="hljs-keyword">implements</span></span> <span class="hljs-title">Comparator</span><<span class="hljs-title">Person</span>> {</span>
    @Override
    <span class="hljs-keyword">public</span> <span class="hljs-keyword">int</span> compare(Person person1, Person person2) {
        <span class="hljs-keyword">return</span> person1.getAge()-person2.getAge();
    }

}</code>

在进行排序的时候将比较器传入即可。

<code class="hljs cs has-numbering">
Person p1=<span class="hljs-keyword">new</span> Person(<span class="hljs-string">"张三"</span>,<span class="hljs-number">23</span>);
Person p2=<span class="hljs-keyword">new</span> Person(<span class="hljs-string">"李四"</span>,<span class="hljs-number">12</span>);
Person p3=<span class="hljs-keyword">new</span> Person(<span class="hljs-string">"王五"</span>,<span class="hljs-number">21</span>);
Person p4=<span class="hljs-keyword">new</span> Person(<span class="hljs-string">"赵六"</span>,<span class="hljs-number">8</span>);
Person p5=<span class="hljs-keyword">new</span> Person(<span class="hljs-string">"钱七"</span>,<span class="hljs-number">40</span>);

List<Person> persons = Arrays.asList(p1, p2, p3, p4, p5);
System.<span class="hljs-keyword">out</span>.println(persons);
Collections.sort(persons,<span class="hljs-keyword">new</span> PersonComparator());
System.<span class="hljs-keyword">out</span>.println(persons);</code>

知道了如何比较一个类并进行排序后，我们开始我们的正式内容，让okhttp支持优先级调度，也就是文章开头的第二种情况。B界面的网络请求比A界面的网络请求优先级要高，因此我们应该有一个变量来代表这种优先级。然后我们需要根据该优先级进行排序。

很遗憾的是Okhttp默认是不支持优先级调度的，我们不得不修改OkHttp底层的源码进行扩展支持，但这又是万不得已的。

在RealCall这个类里面，有一个内部类AsyncCall，所有异步执行的网络请求最终都会被包装成这一个类型。OkHttpClient中的newCall将Request对象包装成RealCall，而RealCall中的enqueue则将自己转换成一个AsyncCall对象进行异步执行，AsyncCall是Runnale对象的间接子类。因此，我们代表优先级的变量应该存储在AsyncCall这个类中，也就是priority。

<code class="hljs axapta has-numbering"> <span class="hljs-keyword">final</span> <span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">AsyncCall</span> <span class="hljs-inheritance"><span class="hljs-keyword">extends</span></span> <span class="hljs-title">NamedRunnable</span>{</span>
        <span class="hljs-comment">//other  field</span>
        <span class="hljs-keyword">private</span> <span class="hljs-keyword">int</span> priority;
        <span class="hljs-keyword">private</span> AsyncCall(Callback responseCallback, <span class="hljs-keyword">boolean</span> forWebSocket) {
            <span class="hljs-keyword">super</span>(<span class="hljs-string">"OkHttp %s"</span>, originalRequest.url().toString());
            <span class="hljs-comment">//other field</span>
            <span class="hljs-keyword">this</span>.priority = originalRequest.priority();
        }

        <span class="hljs-keyword">int</span> priority() {
            <span class="hljs-keyword">return</span> originalRequest.priority();
        }
        <span class="hljs-comment">//other method</span>
    }</code>

同样的，我们需要在Request中暴露这个优先级的变量，即priority

<code class="hljs cs has-numbering"><span class="hljs-keyword">public</span> final <span class="hljs-keyword">class</span> Request {
  <span class="hljs-comment">//other field</span>
  <span class="hljs-keyword">private</span> final <span class="hljs-keyword">int</span> priority;
  <span class="hljs-keyword">private</span> <span class="hljs-title">Request</span>(Builder builder) {
    <span class="hljs-comment">//other field</span>
    <span class="hljs-keyword">this</span>.priority=builder.priority;
  }
  <span class="hljs-keyword">public</span> <span class="hljs-keyword">int</span> <span class="hljs-title">priority</span>(){
    <span class="hljs-keyword">return</span> priority;
  }

  <span class="hljs-comment">//other method</span>
  <span class="hljs-keyword">public</span> <span class="hljs-keyword">static</span> <span class="hljs-keyword">class</span> Builder {
    <span class="hljs-comment">//ohther field</span>
    <span class="hljs-keyword">private</span> <span class="hljs-keyword">int</span> priority;
    <span class="hljs-keyword">private</span> <span class="hljs-title">Builder</span>(Request request) {
      <span class="hljs-comment">//other field</span>
      <span class="hljs-keyword">this</span>.priority=request.priority;
    }

    <span class="hljs-keyword">public</span> Builder <span class="hljs-title">priority</span>(<span class="hljs-keyword">int</span> priority){
      <span class="hljs-keyword">this</span>.priority=priority;
      <span class="hljs-keyword">return</span> <span class="hljs-keyword">this</span>;
    }
    <span class="hljs-comment">//other method</span>
  }
}</code>

之后我们需要实现一个比较器，根据优先级由大到小进行排序

<code class="hljs php has-numbering"><span class="hljs-keyword">public</span> <span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">AsycCallComparator</span><<span class="hljs-title">T</span>> <span class="hljs-keyword">implements</span> <span class="hljs-title">Comparator</span><<span class="hljs-title">T</span>> {</span>
    @Override
    <span class="hljs-keyword">public</span> int compare(T object1, T object2) {
        <span class="hljs-keyword">if</span> ((object1 <span class="hljs-keyword">instanceof</span> RealCall.AsyncCall)
                && (object2 <span class="hljs-keyword">instanceof</span> RealCall.AsyncCall)) {
            RealCall.AsyncCall task1 = (RealCall.AsyncCall) object1;
            RealCall.AsyncCall task2 = (RealCall.AsyncCall) object2;
            int result = task2.priority()
                    - task1.priority();
            <span class="hljs-keyword">return</span> result;
        }
        <span class="hljs-keyword">return</span> <span class="hljs-number">0</span>;
    }</code>

然后，OkHttp内部有一个Dispatcher分发器，分发器内部有一个ExecutorService，ExecutorService是可以自己进行配置，然后变成可以根据优先级调度的，默认的分发器是使用SynchronousQueue进行调度，我们需要将它改成优先队列，将原来的新建对象注释掉，替换成我们的优先队列，优先队列的创建需要传入一个比较器，也就是刚才我们创建的那个比较器。

下面这个方法就是Dispatcher中设置线程池的方法

<code class="hljs java has-numbering">    <span class="hljs-keyword">public</span> <span class="hljs-keyword">synchronized</span> ExecutorService <span class="hljs-title">executorService</span>() {
        <span class="hljs-keyword">if</span> (executorService == <span class="hljs-keyword">null</span>) {
<span class="hljs-comment">//          executorService = new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60, TimeUnit.SECONDS,</span>
<span class="hljs-comment">//                  new SynchronousQueue<Runnable>(), Util.threadFactory("OkHttp Dispatcher", false));</span>
            executorService = <span class="hljs-keyword">new</span> ThreadPoolExecutor(<span class="hljs-number">4</span>, Integer.MAX_VALUE, <span class="hljs-number">60</span>, TimeUnit.SECONDS,
                    <span class="hljs-keyword">new</span> PriorityBlockingQueue<Runnable>(<span class="hljs-number">60</span>, <span class="hljs-keyword">new</span> AsycCallComparator<Runnable>()), Util.threadFactory(<span class="hljs-string">"OkHttp Dispatcher"</span>, <span class="hljs-keyword">false</span>));
        }
        <span class="hljs-keyword">return</span> executorService;
    }
</code>

之后我们模拟发送10个不同优先级的请求，并且优先级是乱序的，控制台则会输出

<code class="hljs livecodeserver has-numbering"><span class="hljs-number">14</span>===Response{protocol=<span class="hljs-keyword">http</span>/<span class="hljs-number">1.1</span>, code=<span class="hljs-number">200</span>, message=OK, url=<span class="hljs-keyword">https</span>://www.baidu.com/}

<span class="hljs-number">500</span>===Response{protocol=<span class="hljs-keyword">http</span>/<span class="hljs-number">1.1</span>, code=<span class="hljs-number">200</span>, message=OK, url=<span class="hljs-keyword">https</span>://www.baidu.com/}

<span class="hljs-number">100</span>===Response{protocol=<span class="hljs-keyword">http</span>/<span class="hljs-number">1.1</span>, code=<span class="hljs-number">200</span>, message=OK, url=<span class="hljs-keyword">https</span>://www.baidu.com/}

<span class="hljs-number">40</span>===Response{protocol=<span class="hljs-keyword">http</span>/<span class="hljs-number">1.1</span>, code=<span class="hljs-number">200</span>, message=OK, url=<span class="hljs-keyword">https</span>://www.baidu.com/}

<span class="hljs-number">34</span>===Response{protocol=<span class="hljs-keyword">http</span>/<span class="hljs-number">1.1</span>, code=<span class="hljs-number">200</span>, message=OK, url=<span class="hljs-keyword">https</span>://www.baidu.com/}

<span class="hljs-number">30</span>===Response{protocol=<span class="hljs-keyword">http</span>/<span class="hljs-number">1.1</span>, code=<span class="hljs-number">200</span>, message=OK, url=<span class="hljs-keyword">https</span>://www.baidu.com/}

<span class="hljs-number">20</span>===Response{protocol=<span class="hljs-keyword">http</span>/<span class="hljs-number">1.1</span>, code=<span class="hljs-number">200</span>, message=OK, url=<span class="hljs-keyword">https</span>://www.baidu.com/}

<span class="hljs-number">10</span>===Response{protocol=<span class="hljs-keyword">http</span>/<span class="hljs-number">1.1</span>, code=<span class="hljs-number">200</span>, message=OK, url=<span class="hljs-keyword">https</span>://www.baidu.com/}

<span class="hljs-number">5</span>===Response{protocol=<span class="hljs-keyword">http</span>/<span class="hljs-number">1.1</span>, code=<span class="hljs-number">200</span>, message=OK, url=<span class="hljs-keyword">https</span>://www.baidu.com/}

<span class="hljs-number">2</span>===Response{protocol=<span class="hljs-keyword">http</span>/<span class="hljs-number">1.1</span>, code=<span class="hljs-number">200</span>, message=OK, url=<span class="hljs-keyword">https</span>://www.baidu.com/}</code>

很明显的看到除了第一个请求外，其他请求是一个有序的优先队列。

这只是一个简单的实现参考，具体实现方案还得看你自己的需求。

这样是扩展了OkHttp支持优先级调度，但是最终还是通过修改底源码实现，虽然修改的代码不多，但也是修改，在不到万不得已的情况下，还是建议不要这么干。

我将修改后的OkHttp源码放到了Github上，有兴趣的可以下过来进行参考。

https://github.com/lizhangqu/PriorityOkHttp