OkHttp3源码解析05-连接池

我们都知道HTTP协议采用请求-应答模式，为了解决TCP握手和挥手效率的问题，HTTP有一个keepalive模式。

当使用普通模式(非KeppAlive模式)时，每个请求-应答都要新建一个连接，完成后立即断开连接(HTTP是无连接的协议)
当使用KeepAlive模式(又称持久连接、连接重用)时，KeepAlive功能使客户端到服务器连接持续有效，避免了频繁地重新建立连接。

http 1.0中默认是关闭的，需要在http头加入”Connection: Keep-Alive”，才能启用Keep-Alive；http 1.1中默认启用Keep-Alive，如果加入”Connection: close “，才关闭。目前大部分浏览器都是用http1.1协议，也就是说默认都会发起Keep-Alive的连接请求。
HTTP Keep-Alive模式
谈HTTP的KeepAlive

OKHttp对KeepAlive的处理

OKHTTP默认支持5个Socket，默认KeepAlive的时间为5分钟，对于连接池的管理通过ConnectionPool来实现。

public final class ConnectionPool {

    //线程池
    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));

    //空闲的socket最大连接数 (默认构造方法会赋值为5)
    private final int maxIdleConnections;
    //socket的keepAlive时间 (默认构造方法会赋值为5)
    private final long keepAliveDurationNs;
    //连接队列
    private final Deque<RealConnection> connections = new ArrayDeque<>();
    //记录连接失败的线路名单
    final RouteDatabase routeDatabase = new RouteDatabase();
    boolean cleanupRunning;

    //...
}  

其中，通过put和get方法来放入连接和获取连接。

先来看put方法，可以看到，在加入到connections之前会先调用cleanupRunnable这个runnable清理空闲的线程。

void put(RealConnection connection) {
    assert (Thread.holdsLock(this)); //检测线程是否拥有锁
    if (!cleanupRunning) {
      cleanupRunning = true;
      executor.execute(cleanupRunnable);
    }
    connections.add(connection);
}  

再来看get方法，这里会遍历整个connections集合，当次数小于限制的大小，并且request的地址的缓存列表中此连接的地址完全匹配时，则直接复用缓存列表中的connection作为request的连接。

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;
}  

public void acquire(RealConnection connection) {
    connection.allocations.add(new WeakReference<>(this));
}   

自动回收连接

之前提到在put方法的时候，会先调用cleanupRunnable来清理空闲的线程。

而OKHTTP是根据StreamAllocation引用计数是否为0来实现自动回收连接的。引用计数通过StreamAllocation的acquire和release方法来完成，实际上是在改动RealConnection的allocations列表的大小。

public void acquire(RealConnection connection) {
    connection.allocations.add(new WeakReference<>(this));
}

private void release(RealConnection connection) {
    for (int i = 0, size = connection.allocations.size(); i < size; i++) {
      Reference<StreamAllocation> reference = connection.allocations.get(i);
      if (reference.get() == this) {
        connection.allocations.remove(i);
        return;
      }
    }
    throw new IllegalStateException();
}  

再来看cleanupRunnable

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方法来进行清理，并返回下次需要清理的间隔时间，然后调用wait方法进行等待一释放锁和时间片。当等待时间到了后，再次进行清理，并返回下次要清理的时间间隔，如此循环下去。

再来看cleanup方法，首先要明确的longestIdleDurationNs是空闲连接的keepAlive存活时间，idleConnectionCount是空闲连接数，inUseConnectionCount时活跃连接数。

long cleanup(long now) {
    int inUseConnectionCount = 0;
    int idleConnectionCount = 0;
    RealConnection longestIdleConnection = null;
    long longestIdleDurationNs = Long.MIN_VALUE;

    synchronized (this) {
      for (Iterator<RealConnection> i = connections.iterator(); i.hasNext(); ) {
        RealConnection connection = i.next();

        //如果查询后，活跃数>0，则inUseConnectionCount+1
        if (pruneAndGetAllocationCount(connection, now) > 0) {
          inUseConnectionCount++;
          continue;
        }

        idleConnectionCount++;

        long idleDurationNs = now - connection.idleAtNanos;
        if (idleDurationNs > longestIdleDurationNs) {
          longestIdleDurationNs = idleDurationNs;
          longestIdleConnection = connection;
        }
      }

      //如果longestIdleDurationNs(空闲连接的keepAlive)超过5分钟或者  
      //idleConnectionCount(空闲连接数)超过5个，则从Deque中移除此连接
      if (longestIdleDurationNs >= this.keepAliveDurationNs
          || idleConnectionCount > this.maxIdleConnections) {
        connections.remove(longestIdleConnection);
      } else if (idleConnectionCount > 0) {
        //返回此连接即将到期的时间
        return keepAliveDurationNs - longestIdleDurationNs;
      } else if (inUseConnectionCount > 0) {
        //如果活跃连接数>0，则返回默认的keepAlive时间5分钟
        return keepAliveDurationNs;
      } else {
        //没有任何连接，跳出循环并返回-1
        cleanupRunning = false;
        return -1;
      }
    }

    closeQuietly(longestIdleConnection.socket());

    // Cleanup again immediately.
    return 0;
}  

cleanup方法主要就是根据连接(connection)中的引用计数来计算空闲连接数和活跃连接数，然后标记出空闲的连接。

再来看一下pruneAndGetAllocationCount，这个方法是用于获取当前连接引用的计数。

private int pruneAndGetAllocationCount(RealConnection connection, long now) {
    List<Reference<StreamAllocation>> references = connection.allocations;
    for (int i = 0; i < references.size(); ) { //遍历
      Reference<StreamAllocation> reference = references.get(i);

      if (reference.get() != null) { //如果被使用中，则遍历下一个
        i++;
        continue;
      }

      // 如果未被使用，则从列表中移除
      Internal.logger.warning("A connection to " + connection.route().address().url()
          + " was leaked. Did you forget to close a response body?");
      references.remove(i);
      connection.noNewStreams = true;

      // 如果列表为空，则说明连接没有引用了，这时返回0，表示此连接是空闲连接。
      if (references.isEmpty()) {
        connection.idleAtNanos = now - keepAliveDurationNs;
        return 0;
      }
    }

    //返回列表的size，说明还有这几个地方引用着这个连接，表示此连接是活跃连接
    return references.size();
}

总结

OKHTTP根据HTTP的KeepAlive头域，来判断缓存。
通过一个专门管理连接池的ConnectionPool类，来保存和获取连接，并会每隔一段时间清理过时的连接。