本篇文章为okhttp源码学习笔记系列的第二篇文章，本篇文章的主要内容为okhttp中的连接与连接的管理，因此需要重点介绍连接的概念。客户端通过HTTP协议与服务器进行通信，首先需要建立连接，okhttp并没有使用URLConnection， 而是对socket直接进行封装，在socket之上建立了connection的概念，代表这物理连接。同时，一对请求与响应对应着输出和输入流， okhttp中同样使用流的逻辑概念，建立在connection的物理连接之上进行数据通信，（只不过不知道为什么okhttp中流的类名为HttpCodec）。在HTTP1.1以及之前的协议中，一个连接只能同时支持单个流，而SPDY和HTTP2.0协议则可以同时支持多个流，本文先考虑HTTP1.1协议的情况。connection负责与远程服务器建立连接， HttpCodec负责请求的写入与响应的读出，但是除此之外还存在在一个连接上建立新的流，取消一个请求对应的流，释放完成任务的流等操作，为了使HttpCodec不至于过于复杂，okhttp中引入了StreamAllocation负责管理一个连接上的流，同时在connection中也通过一个StreamAllocation的引用的列表来管理一个连接的流，从而使得连接与流之间解耦。另外，熟悉HTTP协议的同学肯定知道建立连接是昂贵的，因此在请求任务完成以后（即流结束以后）不会立即关闭连接，使得连接可以复用，okhttp中通过ConnecitonPool来完成连接的管理和复用。
因此本文会首先从两个拦截器开始引入StreamAllocation的概念，其次会依次介绍Connection和的一个实现类Connection，最后再通过分析ConnectionPool来分析连接的管理机制，期间还有涉及Rout, RoutSelector等一些为建立连接或建立流有关的辅助类。
0. 从两个拦截器开始
在上一篇文章中我们了解到okhttp中的网络请求过程其实就是一系列拦截器的处理过程，那么我们就可以以这些拦截器为主线看一下okhttp的实现中都做了哪些事情，首先我们再次贴出RealCall#getResponseWithInterceptor方法：
Response getResponseWithInterceptorChain() throws IOException {
// Build a full stack of interceptors.
List<Interceptor> interceptors = new ArrayList<>();
interceptors.addAll(client.interceptors());
interceptors.add(retryAndFollowUpInterceptor);
interceptors.add(new BridgeInterceptor(client.cookieJar()));
interceptors.add(new CacheInterceptor(client.internalCache()));
interceptors.add(new ConnectInterceptor(client));
if (!forWebSocket) {
interceptors.addAll(client.networkInterceptors());
}
interceptors.add(new CallServerInterceptor(forWebSocket));
Interceptor.Chain chain = new RealInterceptorChain(
interceptors, null, null, null, 0, originalRequest);
return chain.proceed(originalRequest);
}从方法中可以看出okhttp内部定义了五个拦截器，分别负责重试（包括失败重连，添加认证头部信息，重定向等），request和response的转换（主要是将Request和Response对象转换成Http协议定义的报文形式）， 缓存以及连接处理，最后一个与其他稍有不同，它负责流的处理， 将请求数据写入到socket的输出流，并从输入流中获取响应数据，这个在第三篇文章中做分析。
本篇文章的重点是连接以及连接管理，可以看出与连接有关的时RetryAndFollowUpInterceptor和ConnectionInterceptor，那么我们就从这两个拦截器开始分析。
在前面一篇文章中我们了解到拦截器会对外提供一个方法，即intercept(chain)方法，在该方法中处理请求，并调用chain.proceed()方法获取响应，处理后返回响应结果，那么我们首先来看RetryAndFollowUpInterceptor#intercept()方法：
@Override public Response intercept(Chain chain) throws IOException {
Request request = chain.request();
streamAllocation = new StreamAllocation(
client.connectionPool(), createAddress(request.url()), callStackTrace);
int followUpCount = 0;
Response priorResponse = null;
while (true) {
...
Response response = null;
boolean releaseConnection = true;
try {
response = ((RealInterceptorChain) chain).proceed(request, streamAllocation, null, null);
releaseConnection = false;
} catch (... e) {
...
} finally {
// We're throwing an unchecked exception. Release any resources.
if (releaseConnection) {
streamAllocation.streamFailed(null);
streamAllocation.release();
}
}
...这里的代码只是前一半，并且做了部分简化，由于本篇文章分析的是连接与连接管理，因此这里我们只关注与连接相关的部分。这里我们看到在该方法中，首先创建了StreamAllocation对象，该对象是连接与流的桥梁，okhttp处理一个请求时，它负责为该请求找到一个合适的连接（找到是指从连接池中复用连接或者创建新连接）， 并在该连接上创建流对象，通过该流对象完成数据通信。这里的流对象负责数据通信，即向socket的输出流中写请求数据，并从socket的输出流中读取响应数据，而StreamAllocation则负责管理流，包括为请求查找连接，并在该连接上建立流对象，将连接封装的socket对象中的输入输出流传递到okhttp流对象中，使他去完成数据通信任务，这是一种功能或责任的分离，这一点有点像之前分析的Request对象和Call对象的关系，另外一个连接也是通过持有一个关于StreamAllocation的集合来管理一个连接上的多个流（只有在SPDY和HTTP2上存在一个连接上多个流，HTTP1.1及1.0则是在一个连接上同时只有一个流对象）。
从代码中我们看到，创建的streamAllocation对象传递到proceed()方法中，之前对于拦截器链的分析中我们知道，在proceed()方法中递归地创建新的chain对象，并添加proceed()方法中传递进来的对象，提供给后面的拦截器使用，这包括StreamAllocation,
Connection, HttpCodec三个主要的类的对象，其中最后一个就是所谓的流对象（不太清楚okhttp为何如此命名）。
RetryAndFollowUpInterceptor#intercept()方法中其他的逻辑我们在之后的文章中再做分析，这里我们主要是需要了解StreamAllocation对象，以及继续熟悉okhttp中拦截器链的执行机制，下面我们再来分析Connection#intercept()方法：
@Override public Response intercept(Chain chain) throws IOException {
RealInterceptorChain realChain = (RealInterceptorChain) chain;
Request request = realChain.request();
StreamAllocation streamAllocation = realChain.streamAllocation();
// We need the network to satisfy this request. Possibly for validating a conditional GET.
boolean doExtensiveHealthChecks = !request.method().equals("GET");
HttpCodec httpCodec = streamAllocation.newStream(client, doExtensiveHealthChecks);
RealConnection connection = streamAllocation.connection();
return realChain.proceed(request, streamAllocation, httpCodec, connection);
}这里没有对代码做简化，可以看出ConnectionInterceptor的代码很简单，我们暂且忽略doExtensiveHealthChecks，这个跟具体的HTTP协议的规则有关， 这里最关键的是streamAllocation的方法，即newStream()方法，该方法负责寻找连接，并在该连接上建立新的流对象，并返回，而connection()方法只不过是分会找到的连接而已，这里看到三个对象在这时都已经分别创建出来，此时传递到InterceptorChain上，CallServerInterceptor就可以使用这些对象完成数据通信了，这一点在下一篇文章中分析流对象时再做分析，这里我们只是关注连接，那么我们就要StreamAllocation开始。
1. 连接与流的桥梁
首先我们明白HTTP通信执行网络请求需要在连接之上建立一个新的流执行该任务， 我们这里将StreamAllocation称之为连接与流的桥梁， 它负责为一次请求寻找连接并建立流，从而完成远程通信，所以StreamAllocation与请求，连接，流都相关，因此我们首先熟悉一下这三个概念，对于它们三个， StreamAllocation类之前的注释已经给出了解释，这里我们首先看一下它的注释：
/**
* This class coordinates the relationship between three entities:
*
* <ul>
* <li><strong>Connections:</strong> physical socket connections to remote servers. These are
* potentially slow to establish so it is necessary to be able to cancel a connection
* currently being connected.
* <li><strong>Streams:</strong> logical HTTP request/response pairs that are layered on
* connections. Each connection has its own allocation limit, which defines how many
* concurrent streams that connection can carry. HTTP/1.x connections can carry 1 stream
* at a time, HTTP/2 typically carry multiple.
* <li><strong>Calls:</strong> a logical sequence of streams, typically an initial request and
* its follow up requests. We prefer to keep all streams of a single call on the same
* connection for better behavior and locality.
* </ul>
...
**/注释说明的很清楚，Connection时建立在Socket之上的物理通信信道，而Stream则是代表逻辑的HTTP请求/响应对， 至于Call，是对一次请求任务或是说请求过程的封装，在第一篇文章中我们已经做出介绍，而一个Call可能会涉及多个流（如请求重定向，auth认证等情况）， 而Okhttp使用同一个连接完成这一系列的流上的请求任务，这一点的实现我们将在介绍RetryInterceptor的部分中说明。
下面我们来思考StreamAllocation所要解决的问题，简单来讲就是在合适的连接之上建立一个新的流，这个问题划分为两步就是寻找连接和新建流。那么，StreamAllocation的数据结构中应该包含Stream(okhttp中将接口的名字定义为HttpCodec)， Connction, 其次为了寻找合适的连接，应该包含一个URL地址， 连接池ConnectionPool, 而方法则应该包括我们前面提到的newStream()方法, 而findConnection则是为之服务的方法，其次在完成请求任务之后应该有finish方法用来关闭流对象，还有终止和取消等方法， 以及释放资源的方法。下面我们从StreamAllocation中寻找对应的属性和方法， 首先来看它的属性域：
public final class StreamAllocation {
public final Address address;
private Route route;
private final ConnectionPool connectionPool;
private final Object callStackTrace;
// State guarded by connectionPool.
private final RouteSelector routeSelector;
private int refusedStreamCount;
private RealConnection connection;
private boolean released;
private boolean canceled;
private HttpCodec codec;
public StreamAllocation(ConnectionPool connectionPool, Address address, Object callStackTrace) {
this.connectionPool = connectionPool;
this.address = address;
this.routeSelector = new RouteSelector(address, routeDatabase());
this.callStackTrace = callStackTrace;
}
...这里我们看并没有使用URL代表一个地址，而是使用Address对象， 如果查看其代码可以看到它封装了一个URL, 其中还包括dns, 代理等信息，可以更好地满足HTTP协议中规定的细节。使用Address对象也可以直接ConnectionPool中查找对应满足条件的连接，同时Address对象可以用于在RoutSelector查询一个合适的路径Rout对象，该Route对象可以用于建立连接， 然后我们忽略标志位和统计信息，剩下的则是Connection和HttpCodec对象，这里我们先忽略调用栈callStackTrace， 不考虑。以上就是它所有的属性域，那么下面我们再来看它最重要的方法，即新建流的方法：
public HttpCodec newStream(OkHttpClient client, boolean doExtensiveHealthChecks) {
int connectTimeout = client.connectTimeoutMillis();
int readTimeout = client.readTimeoutMillis();
int writeTimeout = client.writeTimeoutMillis();
boolean connectionRetryEnabled = client.retryOnConnectionFailure();
try {
RealConnection resultConnection = findHealthyConnection(connectTimeout, readTimeout,
writeTimeout, connectionRetryEnabled, doExtensiveHealthChecks);
HttpCodec resultCodec;
if (resultConnection.http2Connection != null) {
resultCodec = new Http2Codec(client, this, resultConnection.http2Connection);
} else {
resultConnection.socket().setSoTimeout(readTimeout);
resultConnection.source.timeout().timeout(readTimeout, MILLISECONDS);
resultConnection.sink.timeout().timeout(writeTimeout, MILLISECONDS);
resultCodec = new Http1Codec(
client, this, resultConnection.source, resultConnection.sink);
}
synchronized (connectionPool) {
codec = resultCodec;
return resultCodec;
}
} catch (IOException e) {
throw new RouteException(e);
}
}其流程很明确，我们先不考虑HTTP2.0的情况， 流程就是找到合适的良好连接，然后实例化HttpCodec对象，并设置对应的属性，返回该流对象即可，该流对象依赖连接的输入流和输出流，从而可以在流之上进行请求的写入和响应的读出。下面来开findConnection的代码：
/**
* Finds a connection and returns it if it is healthy. If it is unhealthy the process is repeated
* until a healthy connection is found.
*/
private RealConnection findHealthyConnection(int connectTimeout, int readTimeout,
int writeTimeout, boolean connectionRetryEnabled, boolean doExtensiveHealthChecks)
throws IOException {
while (true) {
RealConnection candidate = findConnection(connectTimeout, readTimeout, writeTimeout,
connectionRetryEnabled);
// If this is a brand new connection, we can skip the extensive health checks.
synchronized (connectionPool) {
//successCount记录该连接上执行流任务的次数，为零说明是新建立的连接
if (candidate.successCount == 0) {
return candidate;
}
}
// Do a (potentially slow) check to confirm that the pooled connection is still good. If it
// isn't, take it out of the pool and start again.
if (!candidate.isHealthy(doExtensiveHealthChecks)) { // 判断连接是否可用
noNewStreams(); //在该方法中会设置该Allocation对应的Connection对象的noNewStream标志位，标识这在该连接不再使用，在回收的线程中会将其回收
continue;
}
return candidate;
}
}
/**
* Returns a connection to host a new stream. This prefers the existing connection if it exists,
* then the pool, finally building a new connection.
*/
private RealConnection findConnection(int connectTimeout, int readTimeout, int writeTimeout,
boolean connectionRetryEnabled) throws IOException {
Route selectedRoute;
synchronized (connectionPool) {
//一系列条件判断
...
RealConnection allocatedConnection = this.connection;
if (allocatedConnection != null && !allocatedConnection.noNewStreams) {//noNewStream是一个标识为，标识该连接不可用
return allocatedConnection;
}
// Attempt to get a connection from the pool.
//可以在OkhttpClient中查看到该方法， 其实就是调用connnctionPool.get(address, streamAllocation);
RealConnection pooledConnection = Internal.instance.get(connectionPool, address, this);
if (pooledConnection != null) {
this.connection = pooledConnection;
return pooledConnection;
}
selectedRoute = route;
}
if (selectedRoute == null) {
selectedRoute = routeSelector.next(); //选择下一个路线Rout
synchronized (connectionPool) {
route = selectedRoute;
refusedStreamCount = 0;
}
}
RealConnection newConnection = new RealConnection(selectedRoute);
synchronized (connectionPool) {
acquire(newConnection); //1. 将该StreamAllocation对象，即this 添加到Connection对象的StreamAllocation引用列表中，标识在建立新的流使用到了该连接
Internal.instance.put(connectionPool, newConnection); //2. 将新建的连接加入到连接池， 与get方法类型，也是在OkHttpClient调用的pool.put()方法
this.connection = newConnection;
if (canceled) throw new IOException("Canceled");
}
newConnection.connect(connectTimeout, readTimeout, writeTimeout, address.connectionSpecs(),
connectionRetryEnabled); //3. 连接方法，将在介绍Connection的部分介绍
routeDatabase().connected(newConnection.route()); //4.新建的连接一定可用，所以将该连接移除黑名单
return newConnection;
}
...
/**
* Use this allocation to hold {@code connection}. Each call to this must be paired with a call to
* {@link #release} on the same connection.
*/
public void acquire(RealConnection connection) {
assert (Thread.holdsLock(connectionPool));
connection.allocations.add(new StreamAllocationReference(this, callStackTrace));
}这两个方法完成了寻找合适的连接的功能，这里我们可以将其分成两种类型：
- 从连接池中复用连接，这一点我们在连接管理部分中会有介绍，其实就是从维护的队列中找到合适的连接并返回，查找的依据就是Address对象；
-
新建连接，新建连接需要首先查找一个合适的路径，然后在该路径上实例化一个新的connection对象，在建立一个新的连接以后需要执行一系列的步骤，在代码中已经用注释的方式分四步标出。
在或许到连接以后还需要执行检查过程，通常来说以上两种类型选择的连接都需要执行检查，只是这里新的连接一定可用，所以会跳过检查，其实检查的过程就是查看该连接的socket是否被关闭以及是否可以正常使用，有兴趣的可以自行查看代码。
在建立新的连接以后需要处理一些事情，代码中的中文注释分了四步将其标出，其中需要说明第一步，acquire方法，connection中维护这一张在一个连接上的流的链表，该链表保存的是StreamAllocation的引用 Connction的该链表为空时说明该连接已经可以回收了，这部分在连接管理部分会有说明。其实在调用ConnectionPool.get()方法时，传入StreamAllocation对象也是为了调用StreamAllocation#acquire方法，将该StreamAllocation对象的引用添加到连接对应的链表中，用于管理一个连接上的流。此外还需要说明的两点，一是关于Internal, 这是一个抽象类，该类只有一个实现类，时HttpClient的一个匿名内部类，该类的一系列方法都是一个功能，就是将okhttp3中一些包访问权限的方法对外提供一个public的访问方法，至于为什么这么实现，目前还不太清楚，估计是在Okhttp的框架中方便使用包权限的方法， 如ConnectionPool的put和get方法，在Okhttp的框架代码中通过Internal代理访问， 而在外部使用时无法访问到这些方法，至于还有没有其他考虑有清楚的同学欢迎赐教。
需要说明的第二点是RouteDatabase是一个黑名单，记录着不可用的路线，避免在同一个坑里栽倒两次，connect()方法就是将该路线移除黑名单，这里为了不影响StreamAllocation分析的连贯性，本文将RoutSelector和RouteDatabase等与路线选择相关的代码放到附录部分，这里我们暂且先了解它的功能而不关注它的实现。
至此就分析完了建立新流的过程，那么剩下的就是释放资源的逻辑，由于这一部分很多地方都与连接的复用管理，流的操作以及RetryAndFollowUpInterceptor中的逻辑有关，所以在这里暂且略过，后续部分再做分析，我们此处重点是了解如何查询连接，如何新建连接以及如何新建流对象。
2. 连接
下面开始分析连接对象，在okhttp中定义了Connection的接口，而该接口在okhttp只有一个实现类，即RealConnetion，下面我们重点分析该类。该类的主要功能就是封装Socket并对外提供输入输出流，那么它的内部结构也很容易联想到，它应该持有一个Socket， 并提供一个输入流一个输入流，在功能方法中对外提供connect()方法建立连接。这里由于okhttp是支持Https和HTTP2.0，如果不考虑这两种情况，RealConnection的代码将会比较简单，下面首先来看它的属性域：
public final class RealConnection extends Http2Connection.Listener implements Connection {
private final Route route;
/** The low-level TCP socket. */
private Socket rawSocket;
/**
* The application layer socket. Either an {@link SSLSocket} layered over {@link #rawSocket}, or
* {@link #rawSocket} itself if this connection does not use SSL.
*/
public Socket socket;
...
private Protocol protocol;
...
public int successCount;
public BufferedSource source;
public BufferedSink sink;
public int allocationLimit;
public final List<Reference<StreamAllocation>> allocations = new ArrayList<>();
public boolean noNewStreams;
public long idleAtNanos = Long.MAX_VALUE;
public RealConnection(Route route) {
this.route = route;
}
...RealConnection通过一个Route路线（或者说路由或路径）来建立连接，它封装一个Socket, 由于考虑到Https的情况，socket有可能时SSLSocket或者RawSocket， 所以这里有两个socket域， 一个在底层，一个在上层，由于我们不考虑Https的情况，那么两个就是等价的，我们只需要明白内部建立rawSocket， 对外提供socket就可以了（注释中也已经明白解释）。另外除了输入流和输出流之外还有连接所使用到的协议，在连接方法中会用到，最后剩下的就是跟连接管理部分相关的统计信息，allocationLimit是分配流的数量上限，对应HTTP1.1来说它就是1， allocations在StreamAllocation部分我们已经熟悉，它是用来统计在一个连接上建立了哪些流，通过StreamAllocation的acquire方法和release方法可以将一个allocation对象添加到链表或者移除链表，（不太清楚这两个方法放在connection中是不是更合理一些）， noNewStream之前说过可以简单理解为它标识该连接已经不可用，idleAtNanos记录该连接处于空闲状态的时间，这些将会在第三部分连接管理中做介绍，这里暂且略过不考虑。
下面就开始看它的连接方法， connect()方法
public void connect(int connectTimeout, int readTimeout, int writeTimeout,
List<ConnectionSpec> connectionSpecs, boolean connectionRetryEnabled) {
if (protocol != null) throw new IllegalStateException("already connected");
...
while (protocol == null) {
try {
buildConnection(connectTimeout, readTimeout, writeTimeout, connectionSpecSelector);
} catch (IOException e) {
...
}
}这里对代码做了最大的简化，主要去掉了异常处理的部分以及Https需要考虑的部分，从代码中可以看出，建立连接是通过判断protocol是否为空来确定是否已经建立 连接的， 下面就继续看buildeConnection()方法：
private void buildConnection(int connectTimeout, int readTimeout, int writeTimeout,
ConnectionSpecSelector connectionSpecSelector) throws IOException {
connectSocket(connectTimeout, readTimeout);
establishProtocol(readTimeout, writeTimeout, connectionSpecSelector);
}
private void connectSocket(int connectTimeout, int readTimeout) throws IOException {
Proxy proxy = route.proxy();
Address address = route.address();
//根据是否需要代理建立不同的Socket
rawSocket = proxy.type() == Proxy.Type.DIRECT || proxy.type() == Proxy.Type.HTTP
? address.socketFactory().createSocket()
: new Socket(proxy);
rawSocket.setSoTimeout(readTimeout);
try {
//内部就是调用socket.connect(InetAddress, timeout)方法建立连接
Platform.get().connectSocket(rawSocket, route.socketAddress(), connectTimeout);
} catch (ConnectException e) {
...
}
//获取输入输出流
source = Okio.buffer(Okio.source(rawSocket));
sink = Okio.buffer(Okio.sink(rawSocket));
}
private void establishProtocol(int readTimeout, int writeTimeout,
ConnectionSpecSelector connectionSpecSelector) throws IOException {
if (route.address().sslSocketFactory() != null) {
...
} else {
protocol = Protocol.HTTP_1_1;
socket = rawSocket;
}
if (protocol == Protocol.HTTP_2) {
...
} else {
//HTTP1.1及以下版本中， 每个连接只允许有一个流
this.allocationLimit = 1;
}
}这里同样对代码做了简化，并在重要的地方做了注释， 流程也很清楚，就是建立socket连接，并获取输入输出流，然后设置正确的协议，此时connect()方法就可以跳出while循环，完成连接。
至此，就完成了连接过程，所以如果除去HTTPs和HTTP2的部分，RealConnection的代码很简单，不过对于HTTPS和HTTP2的处理还是挺多，后续还会继续学习。下面再看另外一个概念，流。
3. 连接管理
对于连接的管理主要是分析ConnectionPool，以连接池的形式管理连接的复用， okhttp中尽可能对于相同地址的远程通信复用同一个连接，这样就节省了连接的代价。那么我们现在明白了ConnectionPool所要解决的问题就可以去思考它应当如何实现，它应当具备的功能可以简单分为三个方法，get, put, cleanup，即获取添加和清理的方法。其中最重要也是最复杂的是清理，即在连接池放满的情况下，如何选择需要淘汰的连接。这里需要考虑的指标包括连接的数量，连接的空闲时长等，那么下面我们来看ConnectionPool的代码：
/**
* Manages reuse of HTTP and HTTP/2 connections for reduced network latency. HTTP requests that
* share the same {@link Address} may share a {@link Connection}. This class implements the policy
* of which connections to keep open for future use.
*/
public final class ConnectionPool {
/**
* Background threads are used to cleanup expired connections. There will be at most a single
* thread running per connection pool. The thread pool executor permits the pool itself to be
* garbage collected.
*/
private static final Executor executor = new ThreadPoolExecutor(0 /* corePoolSize */,
Integer.MAX_VALUE /* maximumPoolSize */, 60L /* keepAliveTime */, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>(), Util.threadFactory("OkHttp ConnectionPool", true));
boolean cleanupRunning;
private final Runnable cleanupRunnable = new Runnable() {
...
};
/** The maximum number of idle connections for each address. */
private final int maxIdleConnections;
private final long keepAliveDurationNs;
private final Deque<RealConnection> connections = new ArrayDeque<>();
final RouteDatabase routeDatabase = new RouteDatabase();
/**
* Create a new connection pool with tuning parameters appropriate for a single-user application.
* The tuning parameters in this pool are subject to change in future OkHttp releases. Currently
* this pool holds up to 5 idle connections which will be evicted after 5 minutes of inactivity.
*/
public ConnectionPool() {
this(5, 5, TimeUnit.MINUTES);
}
public ConnectionPool(int maxIdleConnections, long keepAliveDuration, TimeUnit timeUnit) {
this.maxIdleConnections = maxIdleConnections;
this.keepAliveDurationNs = timeUnit.toNanos(keepAliveDuration);
// Put a floor on the keep alive duration, otherwise cleanup will spin loop.
if (keepAliveDuration <= 0) {
throw new IllegalArgumentException("keepAliveDuration <= 0: " + keepAliveDuration);
}
}首先来看它的属性域，最主要的就是connections，可见在ConnectionPool内部以队列的方式存储连接，而routeDatabase是一个黑名单，用来记录不可用的route，但是看代码目测ConnectionPool中并没有使用它，可能后续还有其他用处，此处不做分析。剩下的就是与清理相关的，从名字则可以看出他们的用途，最开始的三个分别是执行清理任务的线程池，标志位以及清理任务，而maxIdleConnections和keepAliveDurationNs则是清理中淘汰连接的指标，这里需要说明的是maxIdleConnections是值每个地址上最大的空闲连接数（如注释所说），看来okhttp只是限制了与同一个远程服务器的空闲连接数量，对整体的空闲连接数量并没有做限制，但是从代码来看并不是如此，该值时标识该连接池中整体的空闲连接的最大数量，当一个连接数量超过这个值时则会触发清理，这里留有疑问，不知注释是何意，
另外还有一个疑问是okhttp并没有限制一个连接池中连接的最大数量，而只是限制了连接池中的最大空闲连接数量，由于不懂HTTP协议，水平也有限，不太清楚这里需不需要限制，有了解的欢迎在评论中告知，不胜感激。
最后我们可以从默认的构造器中看出okhttp允许每个地址同时可以有五个连接，每个连接空闲时间最多为五分钟。
下面我们首先来看较为简单一些的get和put方法
/** Returns a recycled connection to {@code address}, or null if no such connection exists. */
RealConnection get(Address address, StreamAllocation streamAllocation) {
assert (Thread.holdsLock(this));
for (RealConnection connection : connections) {
if (connection.allocations.size() < connection.allocationLimit
&& address.equals(connection.route().address)
&& !connection.noNewStreams) {
streamAllocation.acquire(connection);
return connection;
}
}
return null;
}获取一个connection时按照Address来匹配，而建立连接也是通过Address查询一个合适的Route来建立的，当匹配到连接时，会将新建立的流对应的StreamAllocation添加到connection.allocations中， 如果这里调用connection.allocations.add(StreamAllocation)或者Connection自定义的add方法会不会更清晰一些，不太明白为什么将该任务放在了StreamAllocation的acquire方法中，此处的streamAllocation的acquire方法其实也就是做了这件事情，用来管理一个连接上的流。
put方法
void put(RealConnection connection) {
assert (Thread.holdsLock(this));
if (!cleanupRunning) {
cleanupRunning = true;
executor.execute(cleanupRunnable);
}
connections.add(connection);
}put方法更为简单，就是异步触发清理任务，然后将连接添加到队列中。那么下面开始重点分析它的清理过程，首先来看清理任务的定义：
private final Runnable cleanupRunnable = new Runnable() {
@Override public void run() {
while (true) {
long waitNanos = cleanup(System.nanoTime());
if (waitNanos == -1) return;
if (waitNanos > 0) {
long waitMillis = waitNanos / 1000000L;
waitNanos -= (waitMillis * 1000000L);
synchronized (ConnectionPool.this) {
try {
ConnectionPool.this.wait(waitMillis, (int) waitNanos);
} catch (InterruptedException ignored) {
}
}
}
}
}
};逻辑也很简单，就是调用cleanup方法执行清理，并等待一段时间，持续清理，而等待的时间长度时有cleanup函数返回值指定的，那么我们继续来看cleanup函数
/**
* Performs maintenance on this pool, evicting the connection that has been idle the longest if
* either it has exceeded the keep alive limit or the idle connections limit.
*
* <p>Returns the duration in nanos to sleep until the next scheduled call to this method. Returns
* -1 if no further cleanups are required.
*/
long cleanup(long now) {
int inUseConnectionCount = 0;
int idleConnectionCount = 0;
RealConnection longestIdleConnection = null;
long longestIdleDurationNs = Long.MIN_VALUE;
// Find either a connection to evict, or the time that the next eviction is due.
synchronized (this) {
for (Iterator<RealConnection> i = connections.iterator(); i.hasNext(); ) {
RealConnection connection = i.next();
// If the connection is in use, keep searching.
if (pruneAndGetAllocationCount(connection, now) > 0) {
inUseConnectionCount++;
continue;
}
//统计空闲连接的数量
idleConnectionCount++;
// If the connection is ready to be evicted, we're done.
long idleDurationNs = now - connection.idleAtNanos;
if (idleDurationNs > longestIdleDurationNs) {//找出空闲时间最长的连接以及对应的空闲时间
longestIdleDurationNs = idleDurationNs;
longestIdleConnection = connection;
}
}
if (longestIdleDurationNs >= this.keepAliveDurationNs
|| idleConnectionCount > this.maxIdleConnections) {
// We've found a connection to evict. Remove it from the list, then close it below (outside
// of the synchronized block).
connections.remove(longestIdleConnection); //在符合清理条件下，清理空闲时间最长的连接
} else if (idleConnectionCount > 0) {
// A connection will be ready to evict soon.
return keepAliveDurationNs - longestIdleDurationNs; //不符合清理条件，则返回下次需要执行清理的等待时间
} else if (inUseConnectionCount > 0) {
// All connections are in use. It'll be at least the keep alive duration 'til we run again.
return keepAliveDurationNs; //没有空闲的连接，则隔keepAliveDuration之后再次执行
} else {
// No connections, idle or in use.
cleanupRunning = false; //清理结束
return -1;
}
}
closeQuietly(longestIdleConnection.socket()); //关闭socket资源
// Cleanup again immediately.
return 0; //这里是在清理一个空闲时间最长的连接以后会执行到这里，需要立即再次执行清理
}这里的首先统计空闲连接数量，然后查找最长空闲时间的连接以及对应空闲时长，然后判断是否超出最大空闲连接数量或者超过最大空闲时长，满足其一则执行清理最长空闲时长的连接，然后立即再次执行清理，否则会返回对应的等待时间，代码中中文注释已做说明。方法中用到了一个方法来查看一个连接上分配流的数量，这里不再贴出，有兴趣的可以自行查看。
接下来我们梳理一下清理的任务，清理任务是异步执行的，遵循两个指标，最大空闲连接数量和最大空闲时长，满足其一则清理空闲时长最大的那个连接，然后循环执行，要么等待一段时间，要么继续清理下一个连接，直到清理所有连接，清理任务才可以结束，下一次put方法调用时，如果已经停止的清理任务则会被再次触发开始。
ConnectionPool的主要方法就是这三个，其余的则是工具私有方法或者getter,
setter方法，另外还有一个需要介绍一下我们在StreamAllocation中遇到的方法 connectionBecameIdle标识一个连接处于了空闲状态，即没有流任务，那么就需要调用该方法，有ConnectionPool来决定是否需要清理该连接：
/**
* Notify this pool that {@code connection} has become idle. Returns true if the connection has
* been removed from the pool and should be closed.
*/
boolean connectionBecameIdle(RealConnection connection) {
assert (Thread.holdsLock(this));
if (connection.noNewStreams || maxIdleConnections == 0) {
connections.remove(connection);
return true;
} else {
notifyAll(); // Awake the cleanup thread: we may have exceeded the idle connection limit.
return false;
}
}这里noNewStream标志位之前说过，它可以理解为该连接已经不可用，所以可以直接清理，而maxIdleConnections==0则标识不允许有空闲连接，也是可以直接清理的，否则唤醒清理任务的线程，执行清理方法。
至此则分析完了连接管理的逻辑，其实就是连接复用，主要包括get, put , cleanup三个方法，重点时清理任务的执行，我们可以在OkHttpClient中配置
后记
关于okhttp的连接和连接管理，逻辑还是比较容易理解，但是StreamAllocation的概念在刚接触时还是比较令人费解，但是为了逻辑顺序本篇文章还是从StreamAllocation开始分析，进而引入了连接和连接复用管理部分，读者可在理解了连接和连接复用管理部分的代码以后在回头再去读StreamAllocation的代码或许更容易理解一些。在最初的计划中是将连接与流一起分析，正是因为StreamAlloc
附录
在前面的分析中，我们了解到Connection需要一个Route路径对象来建立连接，在这一部分我们主要分析Route和RouteSelector，来学习okhttp中是如何通过Address对象选择合理的路径对象的，本部分可能比较鸡肋，对整个网络请求的流程并没有太大影响，因此有兴趣的同学可以继续阅读，没有兴趣可以略过，并不影响其他部分的分析。
首先我们先来看一下Address类，这个类用来表示需要连接远程主机的地址，它内部包含url, proxy, dns等信息，还有一些关于Https会用到的验证信息，这里我们不再分析其源码， 代码很简单，只是封装了一些属性域而已。但是它的注释还是可以了解一下，可以更好地把握这个类的作用：
/**
* A specification for a connection to an origin server. For simple connections, this is the
* server's hostname and port. If an explicit proxy is requested (or {@linkplain Proxy#NO_PROXY no
* proxy} is explicitly requested), this also includes that proxy information. For secure
* connections the address also includes the SSL socket factory, hostname verifier, and certificate
* pinner.
*
* <p>HTTP requests that share the same {@code Address} may also share the same {@link Connection}.
*/通过阅读类的注释，我们就可以发现，其实它就是对于连接对应的远程连接的地址说明，一般情况下会是主机名和端口号，也就是url, 在有代理的情况下还会包含代理信息，而对于Https会包含一些其他的验证信息等。
下面我们再来看Route对象，我们还是来看它的注释：
/**
* The concrete route used by a connection to reach an abstract origin server. When creating a
* connection the client has many options:
*
* <ul>
* <li><strong>HTTP proxy:</strong> a proxy server may be explicitly configured for the client.
* Otherwise the {@linkplain java.net.ProxySelector proxy selector} is used. It may return
* multiple proxies to attempt.
* <li><strong>IP address:</strong> whether connecting directly to an origin server or a proxy,
* opening a socket requires an IP address. The DNS server may return multiple IP addresses
* to attempt.
* </ul>
*
* <p>Each route is a specific selection of these options.
*/从注释中我们可以看出，首先Route对象可以用于建立连接，而选择一个合适的Route，有很多种选项，第一个就是Proxy代理，代理可以明确指定，也可以由ProxySelector中返回多个可用的代理，第二个选项就是IP地址，在Java中表示就是InetAddress对象，dns会返回一个服务器对应的多个IP地址，这两个选项在RouteSelector中马上就会看到，下面我们来分析RouteSelector是如何选择Route对象的。
首先来看它的属性域：
/**
* Selects routes to connect to an origin server. Each connection requires a choice of proxy server,
* IP address, and TLS mode. Connections may also be recycled.
*/
public final class RouteSelector {
private final Address address;
private final RouteDatabase routeDatabase;
/* The most recently attempted route. */
private Proxy lastProxy;
private InetSocketAddress lastInetSocketAddress;
/* State for negotiating the next proxy to use. */
private List<Proxy> proxies = Collections.emptyList();
private int nextProxyIndex;
/* State for negotiating the next socket address to use. */
private List<InetSocketAddress> inetSocketAddresses = Collections.emptyList();
private int nextInetSocketAddressIndex;
/* State for negotiating failed routes */
private final List<Route> postponedRoutes = new ArrayList<>();
...
}注释说的也很清楚，连接远程服务器，每一个连接都需要选择一个代理和IP地址，这里我们忽略与HTTPs有关的东西，下面的属性域也就很容易理解，address代表地址， routeDatabase是一个黑名单，存储那些不可用的Route对象，接下来的六个属性则是与Proxy和InetSocketAddress相关了，包括最近使用的，可以选择的，以及下一个可选择的索引值，最后postponedRoutes表示那些加入到黑名单中的且符合地址条件（即满足条件但是之前有过不可用记录的Route对象）所有Route对象集合，当没有可选择余地时会选择使用它们，总比没有要好。
首先我们从构造器开始：
public RouteSelector(Address address, RouteDatabase routeDatabase) {
this.address = address;
this.routeDatabase = routeDatabase;
resetNextProxy(address.url(), address.proxy());
}这里我们看到调用了resetNextProxy()方法，其实可以将其理解为一个初始化或者重置Proxy方法，我们来看起代码：
/** Prepares the proxy servers to try. */
private void resetNextProxy(HttpUrl url, Proxy proxy) {
if (proxy != null) {
// If the user specifies a proxy, try that and only that.
proxies = Collections.singletonList(proxy);
} else {
// Try each of the ProxySelector choices until one connection succeeds.
List<Proxy> proxiesOrNull = address.proxySelector().select(url.uri());
proxies = proxiesOrNull != null && !proxiesOrNull.isEmpty()
? Util.immutableList(proxiesOrNull)
: Util.immutableList(Proxy.NO_PROXY);
}
nextProxyIndex = 0;
}逻辑流程也容易理解，优先使用在address对象中的指定的proxy对象，该方法由构造器调用，传递进来的，如果该Proxy对象为空，则从address.proxySelector中选择一个Proxy， 如果还没有则使用Proxy.NO_PROXY，并将索引初始化为0，接下来我们一并看一下resetInetSocketAddress()方法：
/** Prepares the socket addresses to attempt for the current proxy or host. */
private void resetNextInetSocketAddress(Proxy proxy) throws IOException {
// Clear the addresses. Necessary if getAllByName() below throws!
inetSocketAddresses = new ArrayList<>();
String socketHost;
int socketPort;
if (proxy.type() == Proxy.Type.DIRECT || proxy.type() == Proxy.Type.SOCKS) {
socketHost = address.url().host();
socketPort = address.url().port();
} else {
SocketAddress proxyAddress = proxy.address();
...
InetSocketAddress proxySocketAddress = (InetSocketAddress) proxyAddress;
socketHost = getHostString(proxySocketAddress);
socketPort = proxySocketAddress.getPort();
}
...
if (proxy.type() == Proxy.Type.SOCKS) {
inetSocketAddresses.add(InetSocketAddress.createUnresolved(socketHost, socketPort));
} else {
// Try each address for best behavior in mixed IPv4/IPv6 environments.
List<InetAddress> addresses = address.dns().lookup(socketHost);
for (int i = 0, size = addresses.size(); i < size; i++) {
InetAddress inetAddress = addresses.get(i);
inetSocketAddresses.add(new InetSocketAddress(inetAddress, socketPort));
}
}
nextInetSocketAddressIndex = 0;
}这里省略了部分条件判断，逻辑流程同意很清楚，首先是获取到主机地址和端口号，然后创建InetSocketAddress或者通过address中的dns查询所有有可能的InetSocketAddress地址。在有了以上的了解以后我们就可以看RouteSelector中最重要的方法，即选择一个Route对象，next()方法：
public Route next() throws IOException {
// Compute the next route to attempt.
if (!hasNextInetSocketAddress()) {
if (!hasNextProxy()) {
if (!hasNextPostponed()) {
throw new NoSuchElementException();
}
return nextPostponed();
}
lastProxy = nextProxy();
}
lastInetSocketAddress = nextInetSocketAddress();
Route route = new Route(address, lastProxy, lastInetSocketAddress);
if (routeDatabase.shouldPostpone(route)) {
postponedRoutes.add(route);
// We will only recurse in order to skip previously failed routes. They will be tried last.
return next();
}
return route;
}这段代码第一次看可能有些迷惑，不过仔细去分析其实逻辑很清晰，首先我们假定还有可用的InetSocketAddress，那么通过nextInetSocketAddress()直接获取并创建Route对象，然后检查是否在黑名单中，在黑名单则加入候选队列，其实就是最后迫于无奈才会使用。如果没有了InetSocketAddress，则选择下一个可用的代理Proxy，在nextProxy中会调用resetNextInetSocketAddress()方法重置InetSocketAddress的队列，继续查询下个可用的InetSocketAddress对象，如果没有可用的Proxy，则从候选队列中postpone中选择，即迫于无奈的选择，如果候选队列也为空那就无能为力了，只能抛异常。这样就分析完了整个选择路径的过程，过程的逻辑很清晰也很容易理解，另外该类中还有一些其他的方法，如用于更新黑名单等，有兴趣的可以自行查阅。
分析到这里，整个连接的过程就分析结束了，可以总结为在网络请求过程中，首先创建一个StreamAllocation的对象，然后调用其newStream()方法，查找一个可用连接，要么复用连接，要么新建连接，复用连接则根据address从连接池中查找，新建连接则是根据address查找一个Route对象建立连接，建立连接以后会将该连接添加到连接池中，同时连接池的清理任务停止的情况下，添加新的连接进去会触发开启清理任务。这是建立连接和管理连接的整个过程，当拥有连接以后，StreamAllocation就会在连接上建立一个流对象，该流持有connection的输入输出流，也就是socket的输入输出流，通过它们最终完成数据通信的过程，所以下一节中将会重点分析流对象Http1Codec，以及数据通信的过程。
