okhttp源码学习笔记(二)-- 连接与连接管理

本篇文章为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));
 }

这两个方法完成了寻找合适的连接的功能,这里我们可以将其分成两种类型:

  1. 从连接池中复用连接,这一点我们在连接管理部分中会有介绍,其实就是从维护的队列中找到合适的连接并返回,查找的依据就是Address对象;
  2. 新建连接,新建连接需要首先查找一个合适的路径,然后在该路径上实例化一个新的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,以及数据通信的过程。

推荐阅读更多精彩内容