Okhttp同步与异步请求知识介绍

浅浅的花香味﹌ 2022-11-04 15:26 630阅读 0赞

## 一、基本概念 ##

**1.1、同步**  
同步请求是指在请求发起到拿到响应结果之前，程序一直会处于阻塞状态，无法接收新的请求，直至拿到响应  
**1.2、异步**  
异步请求是指请求发起后到拿到响应结果之前，程序是非阻塞状态，可以继续接收新的请求，响应回来时会调用一个回调处理响应数据  
**1.3、阻塞**  
阻塞是指请求结果返回之前，当前线程会被挂起。阻塞和同步实质上是不可等同的。对于同步来说，很多时候当前线程仍是处于激活状态的，可以继续处理其他各种消息，只是请求拿不到返回而已。  
**1.4、非阻塞**  
非阻塞与阻塞相对，在不能立刻得到结果之前，不会阻塞当前线程，会立刻返回

最后，阻塞和非阻塞对象不是一个绝对的概念，阻塞里也可能会融入非阻塞的处理；非阻塞里也可能融入阻塞的处理

## 二、Okhttp同步请求 ##

**2.1 优缺点**

同步请求的**好处**在于：理解简单；实现简单；可以将响应结果返回做后续处理；

同步请求的**缺点**在于：不能支持高并发的情况，在对请求响应实时性要求不高的场景下，会影响性能

**2.2 实现方式**

public static String postForPBSerializeForm(String url, JSONObject requestParam){ 
        System.out.println("requestParam: " + requestParam.toJSONString());
        try { 
            OkHttpClient client = new OkHttpClient();
    
            FormBody.Builder formBodyBuilder = new FormBody.Builder();
            formBodyBuilder.add("id", requestParam.getString("id"));
            formBodyBuilder.add("version", requestParam.getString("version"));
            formBodyBuilder.add("mockData", requestParam.getString("mockData"));
            formBodyBuilder.add("type", requestParam.getString("type"));
    
            Request request = new Request.Builder()
                    .post(formBodyBuilder.build())
                    .url(url)
                    .build();
            //okhttp 同步请求关键代码
            Response response = client.newCall(request).execute();
            System.out.println("response.code()：" + response.code() + " " + (response.code() == 200));
            if (response.code() == 200) { 
                return response.body().string();
            }
        }catch (Exception e){ 
            System.out.println("'sdew");
            e.printStackTrace();
        }
        return null;
    }

## 三、Okhttp异步请求 ##

**3.1 优缺点**  
异步请求的**好处**在于：支持高并发的接口请求

异步请求的**缺点**在于：实现复杂；响应结果只能输出，不能返回，不利于接口的后续处理

**3.2 实现方式**

public static String postForPBSerializeFormAsync(String url, JSONObject requestParam){ 
        System.out.println("requestParam: " + requestParam.toJSONString());
        try { 
            OkHttpClient client = new OkHttpClient();
    
            FormBody.Builder formBodyBuilder = new FormBody.Builder();
            formBodyBuilder.add("id", requestParam.getString("id"));
            formBodyBuilder.add("version", requestParam.getString("version"));
            formBodyBuilder.add("mockData", requestParam.getString("mockData"));
            formBodyBuilder.add("type", requestParam.getString("type"));
    
            Request request = new Request.Builder()
                    .post(formBodyBuilder.build())
                    .url(url)
                    .build();
            //okhttp异步请求的关键代码
            Call call=client.newCall(request);
            call.enqueue(new Callback() { 
                @Override
                public void onFailure(Call call, IOException e) { 
                    System.out.println("shibai");
                }
    
                @Override
                public void onResponse(Call call, Response response) throws IOException { 
                    System.out.println("success:" + response.body().string());
                }
            });
        }catch (Exception e){ 
            System.out.println("'sdew");
            e.printStackTrace();
        }
        return null;
    }

**3.3 具体执行流程图**

**3.4 相关知识点介绍**

**3.4.1 Call**

Call是一个接口， A call is a request that has been prepared for execution. A call can be canceled. As this object represents a single request/response pair (stream), it cannot be executed twice.是源码中给出的它的作用和特点。即：（1）一个被准备执行的请求；（2）可以被取消；（3）一个call只能负责去执行一个请求

由于 OkHttpClient 实现了 Call.Factory，因此它具备创建 Call 对象的功能；  
OkHttpClient部分源码：

public class OkHttpClient implements Cloneable, Call.Factory, WebSocket.Factory { 
      /**
       * Prepares the { @code request} to be executed at some point in the future.
       */
      @Override public Call newCall(Request request) { 
        return RealCall.newRealCall(this, request, false /* for web socket */);
      }
    }

**3.4.2 RealCall（Call 的实现类）**

RealCall真正实现了Call接口类内部定义的同步与异步请求、取消请求等方法

RealCall的关键属性

*  OkHttpClient client：就是我们创建的OkHttpClient对象，通过这个对象调用Dispatcher 去分发请求任务；
 *  boolean executed：一个Call只能被执行一次就是这个属性控制的，为true时表示请求已经被执行
 *  Request originalRequest：originalRequest对象是通过OkHttpClient.newCall(request) 传入的 Request 对象，这个对象在整个网络请求中起了非常重要的作用，它会被传入到各个 Interceptor 中。例如用户创建的 Request 对象，只是简单地设置了 url ，method，requestBody 等参数，但是想要发送一个网络请求，这样简单地配置还是不够的，系统提供的拦截器 BridgeInterceptor 就是负责做这件事，它会为该请求添加请求头，例如 gzip，cookie，content-length 等，简单说它会将用户创建的 request 添加一些参数从而使其更加符合向网络请求的 request 。其他拦截器的功能也是对 request 进行操作

**3.4.3 Dispatcher（异步任务分发器）**

异步请求时才会用到Dispatcher，它会内部指定线程池去执行异步任务，并在执行完毕之后提供了finish方法结束异步请求。然后从等待队列中获取下一个满足条件的异步任务去执行。

源码：

/*
 * Copyright (C) 2013 Square, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 package okhttp3;
 
 import java.util.ArrayDeque;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Deque;
 import java.util.Iterator;
 import java.util.List;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.SynchronousQueue;
 import java.util.concurrent.ThreadPoolExecutor;
 import java.util.concurrent.TimeUnit;
 import javax.annotation.Nullable;
 import okhttp3.RealCall.AsyncCall;
 import okhttp3.internal.Util;
 
 /**
 * 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<AsyncCall> readyAsyncCalls = new ArrayDeque<>(); /** Running asynchronous calls. Includes canceled calls that haven't finished yet. */
 private final Deque<AsyncCall> runningAsyncCalls = new ArrayDeque<>();
 
 /** Running synchronous calls. Includes canceled calls that haven't finished yet. */ private final Deque<RealCall> runningSyncCalls = new ArrayDeque<>(); public Dispatcher(ExecutorService executorService) { this.executorService = executorService; } public Dispatcher() { } public synchronized ExecutorService executorService() { if (executorService == null) { executorService = new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60, TimeUnit.SECONDS, new SynchronousQueue<>(), Util.threadFactory("OkHttp Dispatcher", false)); } return executorService; } /** * Set the maximum number of requests to execute concurrently. Above this requests queue in * memory, waiting for the running calls to complete. * * If more than {@code maxRequests} requests are in flight when this is invoked, those requests * will remain in flight. */ public void setMaxRequests(int maxRequests) { if (maxRequests < 1) { throw new IllegalArgumentException("max < 1: " + maxRequests); } synchronized (this) { this.maxRequests = maxRequests; } promoteAndExecute(); } public synchronized int getMaxRequests() { return maxRequests; } /** * Set the maximum number of requests for each host to execute concurrently. This limits requests * by the URL's host name. Note that concurrent requests to a single IP address may still exceed
 * this limit: multiple hostnames may share an IP address or be routed through the same HTTP
 * proxy.
 * * If more than { @code maxRequestsPerHost} requests are in flight when this is invoked, those
 * requests will remain in flight.
 * * WebSocket connections to hosts do not count against this limit.
 */
 public void setMaxRequestsPerHost(int maxRequestsPerHost) { 
 if (maxRequestsPerHost < 1) { 
 throw new IllegalArgumentException("max < 1: " + maxRequestsPerHost);
 }
 synchronized (this) { 
 this.maxRequestsPerHost = maxRequestsPerHost;
 }
 promoteAndExecute();
 }
 
 public synchronized int getMaxRequestsPerHost() { 
 return maxRequestsPerHost;
 }
 
 /**
 * Set a callback to be invoked each time the dispatcher becomes idle (when the number of running
 * calls returns to zero).
 * * Note: The time at which a { @linkplain Call call} is considered idle is different depending
 * on whether it was run { @linkplain Call#enqueue(Callback) asynchronously} or
 * { @linkplain Call#execute() synchronously}. Asynchronous calls become idle after the
 * { @link Callback#onResponse onResponse} or {@link Callback#onFailure onFailure} callback has
 * returned. Synchronous calls become idle once { @link Call#execute() execute()} returns. This
 * means that if you are doing synchronous calls the network layer will not truly be idle until
 * every returned { @link Response} has been closed.
 */
 public synchronized void setIdleCallback(@Nullable Runnable idleCallback) { 
 this.idleCallback = idleCallback;
 }
 
 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();
 }
 
 @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;
 }
 
 /**
 * Cancel all calls currently enqueued or executing. Includes calls executed both { @linkplain
 * Call#execute() synchronously} and {@linkplain Call#enqueue asynchronously}.
 */
 public synchronized void cancelAll() { 
 for (AsyncCall call : readyAsyncCalls) { 
 call.get().cancel();
 }
 
 for (AsyncCall call : runningAsyncCalls) { 
 call.get().cancel();
 }
 
 for (RealCall call : runningSyncCalls) { 
 call.cancel();
 }
 }
 
 /**
 * Promotes eligible calls from { @link #readyAsyncCalls} to {@link #runningAsyncCalls} and runs
 * them on the executor service. Must not be called with synchronization because executing calls
 * can call into user code.
 * * @return true if the dispatcher is currently running calls.
 */
 private boolean promoteAndExecute() { 
 assert (!Thread.holdsLock(this));
 
 List<AsyncCall> executableCalls = new ArrayList<>();
 boolean isRunning;
 synchronized (this) { 
 for (Iterator<AsyncCall> i = readyAsyncCalls.iterator(); i.hasNext(); ) { 
 AsyncCall asyncCall = i.next();
 
 if (runningAsyncCalls.size() >= maxRequests) break; // Max capacity.
 if (asyncCall.callsPerHost().get() >= maxRequestsPerHost) continue; // Host max capacity.
 
 i.remove();
 asyncCall.callsPerHost().incrementAndGet();
 executableCalls.add(asyncCall);
 runningAsyncCalls.add(asyncCall);
 }
 isRunning = runningCallsCount() > 0;
 }
 
 for (int i = 0, size = executableCalls.size(); i < size; i++) { 
 AsyncCall asyncCall = executableCalls.get(i);
 asyncCall.executeOn(executorService());
 }
 
 return isRunning;
 }
 
 /** Used by { @code Call#execute} to signal it is in-flight. */
 synchronized void executed(RealCall call) { 
 runningSyncCalls.add(call);
 }
 
 /** Used by { @code AsyncCall#run} to signal completion. */
 void finished(AsyncCall call) { 
 call.callsPerHost().decrementAndGet();
 finished(runningAsyncCalls, call);
 }
 
 /** Used by { @code Call#execute} to signal completion. */
 void finished(RealCall call) { 
 finished(runningSyncCalls, call);
 }
 
 private <T> void finished(Deque<T> calls, T call) { 
 Runnable idleCallback;
 synchronized (this) { 
 if (!calls.remove(call)) throw new AssertionError("Call wasn't in-flight!");
 idleCallback = this.idleCallback;
 }
 
 boolean isRunning = promoteAndExecute();
 
 if (!isRunning && idleCallback != null) { 
 idleCallback.run();
 }
 }
 
 /** Returns a snapshot of the calls currently awaiting execution. */
 public synchronized List<Call> queuedCalls() { 
 List<Call> result = new ArrayList<>();
 for (AsyncCall asyncCall : readyAsyncCalls) { 
 result.add(asyncCall.get());
 }
 return Collections.unmodifiableList(result);
 }
 
 /** Returns a snapshot of the calls currently being executed. */
 public synchronized List<Call> runningCalls() { 
 List<Call> result = new ArrayList<>();
 result.addAll(runningSyncCalls);
 for (AsyncCall asyncCall : runningAsyncCalls) { 
 result.add(asyncCall.get());
 }
 return Collections.unmodifiableList(result);
 }
 
 public synchronized int queuedCallsCount() { 
 return readyAsyncCalls.size();
 }
 
 public synchronized int runningCallsCount() { 
 return runningAsyncCalls.size() + runningSyncCalls.size();
 }
 }

Dispatcher 的关键属性，这些属性会影响异步请求的执行

*  int maxRequests = 64：指定并发请求的最大个数
 *  int maxRequestsPerHost = 5：每个主机最大请求数为5 ，也就是最多 5 个call共用一个 host。这个host 就是在 RealCall 中通过 originalRequest.url().host() 去获取的，例如 www.baidu.com
 *  ExecutorService executorService：执行异步任务的线程池，在内部已经指定好了线程池，当然也可以在 Dispacther 中通过构造方法去指定一个线程池
 *  Deque readyAsyncCalls：表示在队列中已经准备好的请求
 *  Deque runningAsyncCalls：表示队列中正在执行的异步请求，包括已经取消的请求（还没有执行finish操作的请求）
 *  Deque runningSyncCalls：正在运行的**同步请求**，包括已经取消的请求（还没有执行finish操作的请求）

**3.4.4 AsyncCall**

AsyncCall类是定义在RealCall类中的内部类，表示一个异步请求。在 Dispatcher 中分发的异步请求任务就是 AsyncCall，Dispatcher会从线程池中指定某个线程去执行AsyncCall任务。在 Dispatcher 内部定义了两个队列来存储 AsyncCall，分别是 readyAsyncCalls 和  
runningAsyncCalls。它们分别表示准备要执行的 AsyncCall 队列和正在执行的 AsycnCall 队列；当然还有一个 runningSyncCalls 这个队列，但是它适用于存放 RealCall ，也就是用于**存储同步请求**的任务。

## 四、解决不能返回异步请求的响应结果问题 ##

**参考博客：**  
[Okhttp之同步和异步请求简单分析][Okhttp]  
[OKHTTP异步和同步请求简单分析][OKHTTP]

[Okhttp]: https://blog.csdn.net/chunqiuwei/article/details/77103692
[OKHTTP]: https://www.jianshu.com/p/3214ef86a52d