OkHttp3源码解析05-连接池

港控/mmm° 2023-10-17 16:39 3阅读 0赞

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

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

![450px-HTTP_persistent_connection.svg.png_1903347][]

> http 1.0中默认是关闭的，需要在http头加入”Connection: Keep-Alive”，才能启用Keep-Alive；http 1.1中默认启用Keep-Alive，如果加入”Connection: close “，才关闭。目前大部分浏览器都是用http1.1协议，也就是说默认都会发起Keep-Alive的连接请求。  
> [HTTP Keep-Alive模式][keepalive]  
> [谈HTTP的KeepAlive][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类，来保存和获取连接，并会每隔一段时间清理过时的连接。

[keepalive]: http://www.cnblogs.com/skynet/archive/2010/12/11/1903347.html
[450px-HTTP_persistent_connection.svg.png_1903347]: http://upload.wikimedia.org/wikipedia/commons/thumb/d/d5/HTTP_persistent_connection.svg/450px-HTTP_persistent_connection.svg.png?_=1903347
[HTTP_KeepAlive]: http://www.cnblogs.com/yjf512/archive/2013/07/23/3207850.html