当通过自定义的接口Server返回一个Call对象后,要执行请求就要调用Call的
enQueue方法或者execute方法,由于execute方法是同步方法,所以略过。Call是一个接口,
真正执行该方法的是Call的实现类(仅此一个实现类)RealCall的enqueue方法如下
@Override public void enqueue(Callback responseCallback) {
synchronized (this) {
if (executed) throw new IllegalStateException("Already Executed");
executed = true;
}
captureCallStackTrace();
client.dispatcher().enqueue(new AsyncCall(responseCallback));
}
子类,而client.dispatcher 在我看来是一个线程池。然后这个线程池将我们的回调加入了队列,
然后是Dispatcher的enqueue方法的实现
synchronized void enqueue(AsyncCall call) {
if (runningAsyncCalls.size() < maxRequests && runningCallsForHost(call) < maxRequestsPerHost) {
runningAsyncCalls.add(call);
executorService().execute(call);
} else {
readyAsyncCalls.add(call);
}
}
runningAsyncCalls和readyAsyncCalls是Deque类型的集合,而这个Deque继承与Queue,所以
这是两个队列,从代码可以看出,这个请求一个加入了正在运行的队列,一个加入了准备队列,
准备,加入运行队列之后,接着执行了 executorService().execute(call);
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;
}
而executorService()方法返回了一个ExecutorService对象,该对象实现了Executor接口,而该
接口中,只有一个方法execute(),该方法官方文档给出的实现为
class SerialExecutor implements Executor {
final Queue<Runnable> tasks = new ArrayDeque<Runnable>();
final Executor executor;
Runnable active;
SerialExecutor(Executor executor) {
this.executor = executor;
}
public synchronized void execute(final Runnable r) {
tasks.offer(new Runnable() {
public void run() {
try {
r.run();
} finally {
scheduleNext();
}
}
});
if (active == null) {
scheduleNext();
}
}
protected synchronized void scheduleNext() {
if ((active = tasks.poll()) != null) {
executor.execute(active);
}
}
}
从execute方法中我们可以看出,为什么callback在子线程调用了,那么接下来就是执行的最后一步,在run里进行了什么操作
来看下AsyncCall的构造方法和execute方法
AsyncCall(Callback responseCallback) {
super("OkHttp %s", redactedUrl());
this.responseCallback = responseCallback;
}
@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 {
client.dispatcher().finished(this);
}
}
自这里调用了callback的onFailure和onResponse,那么这里似乎和上边的 SerialExecutor 中的 r.run() 并没有什么关系,那么让我们来看下NamedRunnable的父类
public abstract class NamedRunnable implements Runnable {
protected final String name;
public NamedRunnable(String format, Object... args) {
this.name = Util.format(format, args);
}
@Override public final void run() {
String oldName = Thread.currentThread().getName();
Thread.currentThread().setName(name);
try {
execute();
} finally {
Thread.currentThread().setName(oldName);
}
}
protected abstract void execute();
}
这里可以看到NamedRunnable实现了Runnable并重写的run方法并在其中调用了execute()方法。到这里OkHttp请求流程完成