OkHttp3源码分析[复用连接池]

Posted on By adminPosted in 航天科技Tagged ,

OkHttp系列文章如下

  • OkHttp3源码分析[综述]
  • OkHttp3源码分析[复用连接池]
  • OkHttp3源码分析[缓存策略]
  • OkHttp3源码分析[DiskLruCache]
  • OkHttp3源码分析[职责队列]

1. 概述

HTTP中的keepalive连接于网性优化中，对于延迟降低与快提升的发出特别重大的企图。

万般咱们进行http连接时，首先进行tcp握手，然后传输数据，最后放

图源: Nginx closed

这种办法确实简单，但是以错综复杂的大网内容遭即使不够用了，创建socket需要开展3差握手，而放socket需要2次握手(或者是4软)。重复的连和自由tcp连接就如每次只挤1mm的牙膏就一路上牙膏盖子接着再打开就挤一样。而每次连续大概是TTL一赖的日(也就是是ping一不好)，在TLS环境下消耗的辰哪怕还多了。很肯定，当访问复杂网络时，延时（而不是带宽）将改成那个主要之要素。

当然，上面的题材早都缓解了，在http中产生同栽名叫keepalive connections的机制，它好以传输数据后还是保持连续，当客户端需要再获取数据时，直接用刚刚空下来的连年要非待更握手

图源: Nginx keep_alive

当现代浏览器被，一般以拉开6～8只keepalive connections的socket连接，并保障得之链路生命，当不欲经常再次关闭；而以服务器遭到，一般是出于软件根据负荷情况(比如FD最深价值、Socket内存、超时时间、栈内存、栈数量等)决定是否再接再厉关闭。

Okhttp支持5只连作KeepAlive，默认链路生命为5分钟(链路空闲后，保持现有的辰)

理所当然keepalive也闹缺点，在增强了么客户端性能的而，复用却挡了其余客户端的链路速度，具体来说如下

  1. 冲TCP的死机制，当总水管大小固定时，如果存在大量空闲之keepalive connections（我们得叫做僵尸连接或者泄漏连接），其它客户端们的常规连接速度为会见遭震慑，这为是运营商为何限制P2P连数的道理
  2. 服务器/防火墙上有起限制，比如apache服务器对每个请求都起来线程，导致只支持150个冒出连接（数据来自nginx官网），不过是瓶颈随着高并发server软硬件的发展（golang/分布式/IO多路复用）将会越来越少
  3. 大方之DDOS产生的僵尸连接可能为用来恶意抨击服务器，耗尽资源

吓了，以上大了，本文主要是写客户端的，服务端不再介绍。

下文假设服务器是透过正规的运维配置好之，它默认开启了keep-alive，并无主动关闭连接

2. 连接池的施用及分析

先是先说下源码中着重的目标：

  • Call: 对http的要封装，属于程序员能够接触的上层高级代码
  • Connection:
    对jdk的socket物理连接的包裹，它里面生List<WeakReference<StreamAllocation>>的引用
  • StreamAllocation: 表示Connection吃上层高级代码的援次数
  • ConnectionPool:
    Socket连接池，对连日缓存进行回收及管理，与CommonPool有像样之统筹
  • Deque:
    Deque也即是双端队列，双端队列同时拥有行和储藏室性质，经常在缓存中为采取，这个是java基础

当okhttp中，连接池对用户，甚至开发者都是晶莹剔透的。它自动创建连接池，自动进行泄漏连接回收，自动帮你管理线程池，提供了put/get/clear的接口，甚至里头调用都帮衬您勾勒好了。

以原先的内存泄露剖析文章面临自己形容及，我们理解当socket连接着，也便是Connection遭受，本质是包好的流操作，除非手动close丢失连接，基本不见面吃GC掉，非常容易引发内存泄露。所以当干到连发socket编程时，我们虽见面杀忐忑，往往写出来的代码都是try/catch/finally的迷之缩进，却以针对这样的代码无可奈何。

每当okhttp中，在高层代码的调用中，使用了类似于援计数的办法跟Socket流的调用，这里的计数对象是StreamAllocation，它让数实践aquire与release操作(点击函数可以上github查看)，这简单只函数其实是当改变Connection中的List<WeakReference<StreamAllocation>>大小。List中Allocation的数也不怕是情理socket被引用的计数（Refference
Count），如果计数为0的说话，说明是连续没有吃使用，是悠闲的，需要经过下文的算法实现回收；如果上层代码仍然引用，就未待关闭连接。

引用计数法：给目标吃补充加一个援计数器，每当有一个地方引用它经常，计数器值就加1；当引用失效时，计数器值就减1；任何时刻计数器为0的靶子就是未可能更被利用。它不能够处理循环引用的题目。

2.1. 实例化

每当源码中，我们事先物色ConnectionPool实例化的位置，它是直new出来的，而其的各种操作却在OkHttpClient的static区实现了Internal.instance接口作为ConnectionPool的包装。

关于为何用这样多是一举的子包装，主要是为给外部包之积极分子访问非public方式，详见此注释

2.2. 构造

  1. 连接池内部维护了一个誉为OkHttp ConnectionPool的ThreadPool，专门用来淘汰末位的socket，当满足以下标准时，就会进展末位淘汰，非常像GC

    1. 并发socket空闲连接超过5个
2. 某个socket的keepalive时间大于5分钟

  2. 保护在一个Deque<Connection>，提供get/put/remove等数据结构的机能

  3. 护在一个RouteDatabase，它因此来记录连接失败的Route的非官方名单，当连接失败的时即便会见将黄的路加进去（本文不讨论）

2.3 put/get操作

每当连续池中，提供如下的操作，这里可以看做是针对deque的一个概括的包装

//从连接池中获取
get
//放入连接池
put
//线程变成空闲，并调用清理线程池
connectionBecameIdle
//关闭所有连接
evictAll

随着上述操作让还高级的靶子调用，Connection中的StreamAllocation被不断的aquire与release，也就是List<WeakReference<StreamAllocation>>的大小将随时扭转

2.4 Connection自动回收的实现

java内部有垃圾堆回收GC，okhttp有socket的回收；垃圾回收是基于目标的援树实现之，而okhttp是冲RealConnection的虚引用StreamAllocation援计数是否为0实现之。我们事先看代码

cleanupRunnable:

当用户socket连接成，向连池中put乍的socket时，回收函数会被主动调用，线程池就会见履行cleanupRunnable，如下

//Socket清理的Runnable，每当put操作时，就会被主动调用
//注意put操作是在网络线程
//而Socket清理是在`OkHttp ConnectionPool`线程池中调用
while (true) {
  //执行清理并返回下场需要清理的时间
  long waitNanos = cleanup(System.nanoTime());
  if (waitNanos == -1) return;
  if (waitNanos > 0) {
    synchronized (ConnectionPool.this) {
      try {
        //在timeout内释放锁与时间片
        ConnectionPool.this.wait(TimeUnit.NANOSECONDS.toMillis(waitNanos));
      } catch (InterruptedException ignored) {
      }
    }
  }
}

立段死循环实际上是一个堵塞的清理任务，首先进行清理(clean)，并返回下次亟需清理的间隔时间，然后调用wait(timeout)开展等待以释放锁与时片，当等时到了后，再次展开清理，并返下次如果清理的间隔时间…

Cleanup:

cleanup以了近乎于GC的标记-清除算法，也不怕是首先标记出最为无活跃的接连(我们得以称之为泄漏连接，或者空闲连接)，接着进行消除，流程如下:

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

  //遍历`Deque`中所有的`RealConnection`，标记泄漏的连接
  synchronized (this) {
    for (RealConnection connection : connections) {
      // 查询此连接内部StreamAllocation的引用数量
      if (pruneAndGetAllocationCount(connection, now) > 0) {
        inUseConnectionCount++;
        continue;
      }

      idleConnectionCount++;

      //选择排序法，标记出空闲连接
      long idleDurationNs = now - connection.idleAtNanos;
      if (idleDurationNs > longestIdleDurationNs) {
        longestIdleDurationNs = idleDurationNs;
        longestIdleConnection = connection;
      }
    }

    if (longestIdleDurationNs >= this.keepAliveDurationNs
        || idleConnectionCount > this.maxIdleConnections) {
      //如果(`空闲socket连接超过5个`
      //且`keepalive时间大于5分钟`)
      //就将此泄漏连接从`Deque`中移除
      connections.remove(longestIdleConnection);
    } else if (idleConnectionCount > 0) {
      //返回此连接即将到期的时间，供下次清理
      //这里依据是在上文`connectionBecameIdle`中设定的计时
      return keepAliveDurationNs - longestIdleDurationNs;
    } else if (inUseConnectionCount > 0) {
      //全部都是活跃的连接，5分钟后再次清理
      return keepAliveDurationNs;
    } else {
      //没有任何连接，跳出循环
      cleanupRunning = false;
      return -1;
    }
  }

  //关闭连接，返回`0`，也就是立刻再次清理
  closeQuietly(longestIdleConnection.socket());
  return 0;
}

太长不思看的讲话，就是之类的流程：

  1. 遍历Deque受具备的RealConnection，标记泄漏的总是
  2. 要被标记的接连满足(空闲socket连接超过5个&&keepalive时间大于5分钟)，就用此连续于Deque中移除，并关闭连接，返回0，也不怕是快要执行wait(0)，提醒这还扫描
  3. 如果(目前还可以塞得下5个连接，但是有可能泄漏的连接(即空闲时间即将达到5分钟))，就赶回此连续即将到之剩余时间，供下次清理
  4. 如果(全部都是活跃的连接)，就回来默认的keep-alive日子，也尽管是5分钟后再次实践清理
  5. 如果(没有任何连接)，就返回-1,跳出清理的死循环

重注意：这里的“并作”==(“空闲”＋“活跃”)==5，而不是说并作连接就必然是生动活泼的连

pruneAndGetAllocationCount:

争标记并找到最好无欢的连年为，这里航天科技以了pruneAndGetAllocationCount的方法，它主要依据弱引用是否也null要判断是连续是否泄漏

//类似于引用计数法，如果引用全部为空，返回立刻清理
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);
    //如果正在被使用，跳过，接着循环
    //是否置空是在上文`connectionBecameIdle`的`release`控制的
    if (reference.get() != null) {
      //非常明显的引用计数
      i++;
      continue;
    }

    //否则移除引用
    references.remove(i);
    connection.noNewStreams = true;

    //如果所有分配的流均没了，标记为已经距离现在空闲了5分钟
    if (references.isEmpty()) {
      connection.idleAtNanos = now - keepAliveDurationNs;
      return 0;
    }
  }

  return references.size();
}
  1. 遍历RealConnection连日来着的StreamAllocationList，它保护在一个凋谢引用列表
  2. 查看此StreamAllocation是否也空(它是在线程池的put/remove手动控制的)，如果为空，说明已经远非代码引用这目标了，需要以List中去
  3. 遍历结束，如果List中保护的StreamAllocation删空了，就返回0，表示是连续已远非代码引用了，是泄漏的连接;否则回非0的价值，表示这个还是给引述，是生动活泼的连续。

上述实现的忒保守，实际上用filter就好大体实现，伪代码如下

return references.stream().filter(reference -> {
    return !reference.get() == null;
}).count();

总结

经过地方的剖析，我们好总结，okhttp使用了近似于引用计数法与标记擦除法的杂使用，当连接空闲或者释放时，StreamAllocation的数目会慢慢变成0，从而被线程池监测到连回收，这样就好保多独正规之keep-alive连接，Okhttp的非官方科技就是这么实现之。

最后推荐一依《图解HTTP》，日本丁形容的，看起挺正确。

再次引进阅读开源Redis客户端Jedis的源码，可以拘留下它们的JedisFactory的实现。

倘你指望又多强质量之稿子，不妨关心自我要么点赞吧！

Ref

  1. https://www.nginx.com/blog/http-keepalives-and-web-performance/

发表评论

电子邮件地址不会被公开。 必填项已用*标注