接主文okhttp3.10介绍okhttp的连接复用。
Keep-Alive机制：当一个http请求完成后，tcp连接不会立即释放，如果有新的http请求，并且host和上次一样，那么可以复用tcp连接，省去重新连接的过程。
如果没有开启Keep-Alive，一个http请求就需要一次tcp连接，非常浪费资源。我们来看okhttp与连接相关的四个类，重点看连接的管理。
- Collection
- HttpCodec
- StreamAllocation
- ConnectionPool
连接和流
public interface Connection {
Route route();
Socket socket();
@Nullable Handshake handshake();
Protocol protocol();
}
Connection描述http的物理连接，封装了Socket，具体的实现类是RealConnection，其他三个变量Route、Handshake、Protocol是http协议相关类。（只要知道Connection是请求发送和响应的通道，真系要进入http原理时再讲）
public interface HttpCodec {
Sink createRequestBody(Request request, long contentLength);
void writeRequestHeaders(Request request) throws IOException;
void flushRequest() throws IOException;
void finishRequest() throws IOException;
Response.Builder readResponseHeaders(boolean expectContinue) throws IOException;
ResponseBody openResponseBody(Response response) throws IOException;
void cancel();
}
HttpCodec里是一些read、write方法，使用了okio，它是一个比java.io更高效的库（具体原理先book定下一篇讲）。Source和Sink，分别对应java.io的InputStream和OutputStream，就是输入输出。
http1和http2有不同的实现，http2是未来，看Http1Codec的。
在http1.1，一个连接只能有一个流，而在http2则可以支持多个流。为了管理一个连接上的多个流，okhttp使用StreamAllocation作为连接和流的桥梁。在RealConnection中保存了StreamAllocationd的一个列表，作为连接上流的计数器。如果列表大小为0，表示连接是空闲的，可以回收；否则连接还在用，不能关闭。
public final List<Reference<StreamAllocation>> allocations = new ArrayList<>();
操作allocations对应的增减方法是aquire和release：
public void acquire(RealConnection connection, boolean reportedAcquired) {
assert (Thread.holdsLock(connectionPool));
if (this.connection != null) throw new IllegalStateException();
this.connection = connection;
this.reportedAcquired = reportedAcquired;
connection.allocations.add(new StreamAllocationReference(this, callStackTrace));
}
为连接新增一个流，StreamAllocation用弱引用包装为StreamAllocationReference，直接加入allocations。
释放StreamAllocation管理的流的方法有两个，一个供外部调用，public、没入参的release：
public void release() {
Socket socket;
Connection releasedConnection;
synchronized (connectionPool) {
releasedConnection = connection;
socket = deallocate(false, true, false);
if (connection != null) releasedConnection = null;
}
closeQuietly(socket);
if (releasedConnection != null) {
eventListener.connectionReleased(call, releasedConnection);
}
}
最重要是调用deallocate，为什么返回socket并尝试执行关闭呢？连接上可能有多个流喔！可以猜想到deallocate肯定操作减少allocations，当allocations空了，返回连接的socket关闭。
private Socket deallocate(boolean noNewStreams, boolean released, boolean streamFinished) {
assert (Thread.holdsLock(connectionPool));
if (streamFinished) {
this.codec = null;
}
if (released) {
this.released = true;
}
Socket socket = null;
if (connection != null) {
if (noNewStreams) {
connection.noNewStreams = true;
}
if (this.codec == null && (this.released || connection.noNewStreams)) {
release(connection);
if (connection.allocations.isEmpty()) {
connection.idleAtNanos = System.nanoTime();
if (Internal.instance.connectionBecameIdle(connectionPool, connection)) {
socket = connection.socket();
}
}
connection = null;
}
}
return socket;
}
果然咯，调用私有的release（在allocations里找到当前StreamAllocation并移除）。当allocations为空时返回socket，否则返回null。中间执行connectionBecameIdle，通知ConnectionPool清除这个空闲连接。
连接管理
okhttp使用ConnectionPool管理连接，里面有一个Deque保存所有的连接。
private final Deque<RealConnection> connections = new ArrayDeque<>();
ConnectionPool对象直接在OkHttpClient中new出来，但是访问需要通过在static{}中定义的Internal.instance（为了让外部包的成员访问非public方法）。
ConnectionPool里增减连接的方法有下面几个：
- put
- get
- connectionBecameIdle
- evictAll
看方法名就知道用途，基本是对Deque的操作，看看get方法：
@Nullable RealConnection get(Address address, StreamAllocation streamAllocation, Route route) {
assert (Thread.holdsLock(this));
for (RealConnection connection : connections) {
if (connection.isEligible(address, route)) {
streamAllocation.acquire(connection, true);
return connection;
}
}
return null;
}
获取一个连接需要满足一定的条件，如果能够获取连接，调用streamAllocation.acquire增加一个流。
void put(RealConnection connection) {
assert (Thread.holdsLock(this));
if (!cleanupRunning) {
cleanupRunning = true;
executor.execute(cleanupRunnable);
}
connections.add(connection);
}
put方法直接向connections加入一个连接，加入之前会尝试执行清理工作，触发cleanupRunnable，提交到ConnectionPool内部的线程池执行。
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执行清理并返回下次清理的时间，然后进入wait。
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;
}
}
当一个连接变为空闲时，需要notifyAll，唤醒的就是清理线程。
具体清理过程的方法cleanup比较长，归纳出伪码：
for 所有连接{
1、检查连接是否空闲
2、空闲数量+1
3、标记空闲最久的连接
}
if 空闲时间大于keep-alive时间 或 空闲连接大于5个
移除空闲最久的连接，最后return 0，马上触发下一次cleanup
else if 有空闲连接
return 空闲最久连接剩余到期时间
else if 有在用连接
return keep-alive
else 没有连接
return -1 跳出清理线程
return 0
keep-alive时间在ConnectionPool预设的时间是5分钟，最大空闲连接数量是5个，可以修改。
连接清理剩下最后一个问题，如何判断连接在用呢。回想RealConnection维护的allocations列表，对StreamAllocation使用了弱引用包装。只要弱引用还存在，说明连接还在用。
pruneAndGetAllocationCount检查连接上每个流，并返回在用流的数量。
