Android網絡編程（八）源碼解析OkHttp中篇[復用連接池]

構造函數

  public ConnectionPool() {
  //默認空閒的socket最大連接數為5個，socket的keepAlive時間為5秒
    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);
    }
  }

通過構造函數可以看出ConnectionPool默認的空閒的socket最大連接數為5個，socket的keepAlive時間為5秒。

實例化

ConnectionPool實例化是在OkHttpClient實例化時進行的：

  public OkHttpClient() {
    this(new Builder());
  }

在OkHttpClient的構造函數中調用了new Builder()：

  public Builder() {
      dispatcher = new Dispatcher();
     ...省略
      connectionPool = new ConnectionPool();
     ...省略
    }

緩存操作

ConnectionPool提供對Deque進行操作的方法分別為put、get、connectionBecameIdle和evictAll幾個操作。分別對應放入連接、獲取連接、移除連接和移除所有連接操作，這裡我們舉例put和get操作。

put操作

  void put(RealConnection connection) {
    assert (Thread.holdsLock(this));
    if (!cleanupRunning) {
      cleanupRunning = true;
      executor.execute(cleanupRunnable);
    }
    connections.add(connection);
  }

在添加到Deque之前首先要清理空閒的線程，這個後面會講到。

get操作

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

遍歷connections緩存列表，當某個連接計數的次數小於限制的大小並且request的地址和緩存列表中此連接的地址完全匹配。則直接復用緩存列表中的connection作為request的連接。

自動回收連接

okhttp是根據StreamAllocation引用計數是否為0來實現自動回收連接的。我們在put操作前首先要調用executor.execute(cleanupRunnable)來清理閒置的線程。我們來看看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方法：

  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 i = connections.iterator(); i.hasNext(); ) {
        RealConnection connection = i.next();
        //查詢此連接的StreamAllocation的引用數量，如果大於0則inUseConnectionCount數量加1，否則idleConnectionCount加1
        if (pruneAndGetAllocationCount(connection, now) > 0) {
          inUseConnectionCount++;
          continue;
        }
        idleConnectionCount++;
        long idleDurationNs = now - connection.idleAtNanos;
        if (idleDurationNs > longestIdleDurationNs) {
          longestIdleDurationNs = idleDurationNs;
          longestIdleConnection = connection;
        }
      }
      //如果空閒連接keepAlive時間超過5分鐘，或者空閒連接數超過5個，則從Deque中移除此連接
      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);
       //如果空閒連接大於0，則返回此連接即將到期的時間
      } else if (idleConnectionCount > 0) {
        // A connection will be ready to evict soon.
        return keepAliveDurationNs - longestIdleDurationNs;
        //如果沒有空閒連接，並且活躍連接大於0則返回5分鐘
      } else if (inUseConnectionCount > 0) {
        // All connections are in use. It'll be at least the keep alive duration 'til we run again.
        return keepAliveDurationNs;
      } else {
      //如果沒有任何連接則跳出循環
        cleanupRunning = false;
        return -1;
      }
    }

    closeQuietly(longestIdleConnection.socket());

    // Cleanup again immediately.
    return 0;
  }

cleanup所做的簡單總結就是根據連接中的引用計數來計算空閒連接數和活躍連接數，然後標記出空閒的連接，如果空閒連接keepAlive時間超過5分鐘，或者空閒連接數超過5個，則從Deque中移除此連接。接下來根據空閒連接或者活躍連接來返回下次需要清理的時間數：如果空閒連接大於0則返回此連接即將到期的時間，如果都是活躍連接並且大於0則返回默認的keepAlive時間5分鐘，如果沒有任何連接則跳出循環並返回-1。在上述代碼中的第13行，通過pruneAndGetAllocationCount方法來判斷連接是否閒置的，如果pruneAndGetAllocationCount方法返回值大於0則是空閒連接，否則就是活躍連接，讓我們來看看pruneAndGetAllocationCount方法：

  private int pruneAndGetAllocationCount(RealConnection connection, long now) {
    List> references = connection.allocations;
    //遍歷弱引用列表
    for (int i = 0; i < references.size(); ) {
      Reference reference = references.get(i);
      //若StreamAllocation被使用則接著循環
      if (reference.get() != null) {
        i++;
        continue;
      }

      // We've discovered a leaked allocation. This is an application bug.
      Internal.logger.warning("A connection to " + connection.route().address().url()
          + " was leaked. Did you forget to close a response body?");
      //若StreamAllocation未被使用則移除引用
      references.remove(i);
      connection.noNewStreams = true;

      // If this was the last allocation, the connection is eligible for immediate eviction.
      //如果列表為空則說明此連接沒有被引用了，則返回0，表示此連接是空閒連接
      if (references.isEmpty()) {
        connection.idleAtNanos = now - keepAliveDurationNs;
        return 0;
      }
    }
    //否則返回非0的數，表示此連接是活躍連接
    return references.size();
  }

pruneAndGetAllocationCount方法首先遍歷傳進來的RealConnection的StreamAllocation列表，如果StreamAllocation被使用則接著遍歷下一個StreamAllocation，如果StreamAllocation未被使用則從列表中移除。如果列表為空則說明此連接沒有引用了，則返回0，表示此連接是空閒連接，否則就返回非0的數表示此連接是活躍連接。

總結

可以看出連接池復用的核心就是用Deque來存儲連接，通過put、get、connectionBecameIdle和evictAll幾個操作來對Deque進行操作，另外通過判斷連接中的計數對象StreamAllocation來進行自動回收連接。