okhttp 3.10连接复用原理

接主文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检查连接上每个流，并返回在用流的数量。