HttpClient鏈接池的一些思考

時間  2019-11-05
標籤 httpclient 鏈接 一些 思考 欄目 系統網絡 简体版
原文   原文鏈接

前言

使用apache的httpclient進行http的交互處理已經很長時間了，而httpclient實例則使用了http鏈接池，想必你們也沒有關心過鏈接池的管理。事實上，經過分析httpclient源碼，發現它很優雅地隱藏了全部的鏈接池管理細節，開發者徹底不用花太多時間去思考鏈接池的問題。html

Apache官網例子

CloseableHttpClient httpclient = HttpClients.createDefault();
HttpGet httpget = new HttpGet("http://localhost/");
CloseableHttpResponse response = httpclient.execute(httpget);
try {
    HttpEntity entity = response.getEntity();
    if (entity != null) {
        long len = entity.getContentLength();
        if (len != -1 && len < 2048) {
            System.out.println(EntityUtils.toString(entity));
        } else {
            // Stream content out
        }
    }
} finally {
    response.close();
}

HttpClient及其鏈接池配置

  • 整個線程池中最大鏈接數 MAX_CONNECTION_TOTAL = 800
  • 路由到某臺主機最大併發數，是MAX_CONNECTION_TOTAL（整個線程池中最大鏈接數）的一個細分 ROUTE_MAX_COUNT = 500
  • 重試次數，防止失敗狀況 RETRY_COUNT = 3
  • 客戶端和服務器創建鏈接的超時時間 CONNECTION_TIME_OUT = 5000
  • 客戶端從服務器讀取數據的超時時間 READ_TIME_OUT = 7000
  • 從鏈接池中獲取鏈接的超時時間 CONNECTION_REQUEST_TIME_OUT = 5000
  • 鏈接空閒超時，清楚閒置的鏈接 CONNECTION_IDLE_TIME_OUT = 5000
  • 鏈接保持存活時間 DEFAULT_KEEP_ALIVE_TIME_MILLIS = 20 * 1000

MaxtTotal和DefaultMaxPerRoute的區別

  • MaxtTotal是整個池子的大小；
  • DefaultMaxPerRoute是根據鏈接到的主機對MaxTotal的一個細分；

好比：MaxtTotal=400，DefaultMaxPerRoute=200，而我只鏈接到http://hjzgg.com時，到這個主機的併發最多隻有200；而不是400；而我鏈接到http://qyxjj.com 和 http://httls.com時，到每一個主機的併發最多隻有200；即加起來是400（但不能超過400）。因此起做用的設置是DefaultMaxPerRoute。apache

HttpClient鏈接池模型

HttpClient從鏈接池中獲取鏈接分析

org.apache.http.pool.AbstractConnPool設計模式

private E getPoolEntryBlocking(
        final T route, final Object state,
        final long timeout, final TimeUnit tunit,
        final PoolEntryFuture<E> future)
            throws IOException, InterruptedException, TimeoutException {


    Date deadline = null;
    if (timeout > 0) {
        deadline = new Date
            (System.currentTimeMillis() + tunit.toMillis(timeout));
    }


    this.lock.lock();
    try {
        final RouteSpecificPool<T, C, E> pool = getPool(route);//這是每個路由細分出來的鏈接池
        E entry = null;
        while (entry == null) {
            Asserts.check(!this.isShutDown, "Connection pool shut down");
            //從池子中獲取一個可用鏈接並返回
            for (;;) {
                entry = pool.getFree(state);
                if (entry == null) {
                    break;
                }
                if (entry.isExpired(System.currentTimeMillis())) {
                    entry.close();
                } else if (this.validateAfterInactivity > 0) {
                    if (entry.getUpdated() + this.validateAfterInactivity <= System.currentTimeMillis()) {
                        if (!validate(entry)) {
                            entry.close();
                        }
                    }
                }
                if (entry.isClosed()) {
                    this.available.remove(entry);
                    pool.free(entry, false);
                } else {
                    break;
                }
            }
            if (entry != null) {
                this.available.remove(entry);
                this.leased.add(entry);
                onReuse(entry);
                return entry;
            }

            //建立新的鏈接
            // New connection is needed
            final int maxPerRoute = getMax(route);//獲取當前路由最大併發數
            // Shrink the pool prior to allocating a new connection
            final int excess = Math.max(0, pool.getAllocatedCount() + 1 - maxPerRoute);
            if (excess > 0) {//若是當前路由對應的鏈接池的鏈接超過最大路由併發數，獲取到最後使用的一次鏈接，釋放掉
                for (int i = 0; i < excess; i++) {
                    final E lastUsed = pool.getLastUsed();
                    if (lastUsed == null) {
                        break;
                    }
                    lastUsed.close();
                    this.available.remove(lastUsed);
                    pool.remove(lastUsed);
                }
            }

            //嘗試建立新的鏈接 
            if (pool.getAllocatedCount() < maxPerRoute) {//當前路由對應的鏈接池可用空閒鏈接數+當前路由對應的鏈接池已用鏈接數 < 當前路由對應的鏈接池最大併發數
                final int totalUsed = this.leased.size();
                final int freeCapacity = Math.max(this.maxTotal - totalUsed, 0);
                if (freeCapacity > 0) {
                    final int totalAvailable = this.available.size();
                    if (totalAvailable > freeCapacity - 1) {//線程池中可用空閒鏈接數 > (線程池中最大鏈接數 - 線程池中已用鏈接數 - 1)
                        if (!this.available.isEmpty()) {
                            final E lastUsed = this.available.removeLast();
                            lastUsed.close();
                            final RouteSpecificPool<T, C, E> otherpool = getPool(lastUsed.getRoute());
                            otherpool.remove(lastUsed);
                        }
                    }
                    final C conn = this.connFactory.create(route);
                    entry = pool.add(conn);
                    this.leased.add(entry);
                    return entry;
                }
            }


            boolean success = false;
            try {
                pool.queue(future);
                this.pending.add(future);
                success = future.await(deadline);
            } finally {
                // In case of 'success', we were woken up by the
                // connection pool and should now have a connection
                // waiting for us, or else we're shutting down.
                // Just continue in the loop, both cases are checked.
                pool.unqueue(future);
                this.pending.remove(future);
            }
            // check for spurious wakeup vs. timeout
            if (!success && (deadline != null) &&
                (deadline.getTime() <= System.currentTimeMillis())) {
                break;
            }
        }
        throw new TimeoutException("Timeout waiting for connection");
    } finally {
        this.lock.unlock();
    }
}

鏈接重用和保持策略

http的長鏈接複用， 其斷定規則主要分兩類。
  1. http協議支持+請求/響應header指定
  2. 一次交互處理的完整性(響應內容消費乾淨)
  對於前者, httpclient引入了ConnectionReuseStrategy來處理, 默認的採用以下的約定：api

  • HTTP/1.0經過在Header中添加Connection:Keep-Alive來表示支持長鏈接。
  • HTTP/1.1默認支持長鏈接, 除非在Header中顯式指定Connection:Close, 才被視爲短鏈接模式。

HttpClientBuilder建立MainClientExec

ConnectionReuseStrategy（鏈接重用策略） 

org.apache.http.impl.client.DefaultClientConnectionReuseStrategy服務器

MainClientExec處理鏈接

處理完請求後，獲取到response，經過ConnectionReuseStrategy判斷鏈接是否可重用，若是是經過ConnectionKeepAliveStrategy獲取到鏈接最長有效時間，並設置鏈接可重用標記。併發

鏈接重用判斷邏輯

  • request首部中包含Connection:Close，不復用
  • response中Content-Length長度設置不正確，不復用
  • response首部包含Connection:Close，不復用
  • reponse首部包含Connection:Keep-Alive，複用
  • 都沒命中的狀況下，若是HTTP版本高於1.0則複用

更多參考：https://www.cnblogs.com/mumuxinfei/p/9121829.htmlapp

鏈接釋放原理分析

HttpClientBuilder會構建一個InternalHttpClient實例，也是CloseableHttpClient實例。InternalHttpClient的doExecute方法來完成一次request的執行。dom

會繼續調用MainClientExec的execute方法，經過鏈接池管理者獲取鏈接（HttpClientConnection）。oop

構建ConnectionHolder類型對象，傳遞鏈接池管理者對象和當前鏈接對象。ui

請求執行完返回HttpResponse類型對象，而後包裝成HttpResponseProxy對象（是CloseableHttpResponse實例）返回。

CloseableHttpClient類其中一個execute方法以下，finally方法中會調用HttpResponseProxy對象的close方法釋放鏈接。

最終調用ConnectionHolder的releaseConnection方法釋放鏈接。

CloseableHttpClient類另外一個execute方法以下，返回一個HttpResponseProxy對象（是CloseableHttpResponse實例）。 

這種狀況下調用者獲取了HttpResponseProxy對象，能夠直接拿到HttpEntity對象。你們關心的就是操做完HttpEntity對象，使用完InputStream到底需不須要手動關閉流呢？

其實調用者不須要手動關閉流，由於HttpResponseProxy構造方法裏有加強HttpEntity的處理方法，以下。

調用者最終拿到的HttpEntity對象是ResponseEntityProxy實例。

ResponseEntityProxy重寫了獲取InputStream的方法，返回的是EofSensorInputStream類型的InputStream對象。

EofSensorInputStream對象每次讀取都會調用checkEOF方法，判斷是否已經讀取完畢。

checkEOF方法會調用ResponseEntityProxy（實現了EofSensorWatcher接口）對象的eofDetected方法。

EofSensorWatcher#eofDetected方法中會釋放鏈接並關閉流。

 

綜上，經過CloseableHttpClient實例處理請求，無需調用者手動釋放鏈接。

HttpClient在Spring中應用

建立ClientHttpRequestFactory

@Bean
public ClientHttpRequestFactory clientHttpRequestFactory()
        throws KeyStoreException, NoSuchAlgorithmException, KeyManagementException {
    HttpClientBuilder httpClientBuilder = HttpClientBuilder.create();
    SSLContext sslContext = new SSLContextBuilder().loadTrustMaterial(null, (arg0, arg1) -> true).build();

    httpClientBuilder.setSSLContext(sslContext)
            .setMaxConnTotal(MAX_CONNECTION_TOTAL)
            .setMaxConnPerRoute(ROUTE_MAX_COUNT)
            .evictIdleConnections(CONNECTION_IDLE_TIME_OUT, TimeUnit.MILLISECONDS);

    httpClientBuilder.setRetryHandler(new DefaultHttpRequestRetryHandler(RETRY_COUNT, true));
    httpClientBuilder.setKeepAliveStrategy(new DefaultConnectionKeepAliveStrategy());
    CloseableHttpClient client = httpClientBuilder.build();

    HttpComponentsClientHttpRequestFactory clientHttpRequestFactory = new HttpComponentsClientHttpRequestFactory(client);
    clientHttpRequestFactory.setConnectTimeout(CONNECTION_TIME_OUT);
    clientHttpRequestFactory.setReadTimeout(READ_TIME_OUT);
    clientHttpRequestFactory.setConnectionRequestTimeout(CONNECTION_REQUEST_TIME_OUT);
    clientHttpRequestFactory.setBufferRequestBody(false);
    return clientHttpRequestFactory;
}

建立RestTemplate

@Bean
public RestTemplate restTemplate()  {
   RestTemplate restTemplate = new RestTemplate(clientHttpRequestFactory());
        restTemplate.setErrorHandler(new DefaultResponseErrorHandler());
        // 修改StringHttpMessageConverter內容轉換器
        restTemplate.getMessageConverters().set(1, new StringHttpMessageConverter(StandardCharsets.UTF_8));
        return restTemplate;
}

 Spring官網例子

@SpringBootApplication
public class Application {

    private static final Logger log = LoggerFactory.getLogger(Application.class);

    public static void main(String args[]) {
        SpringApplication.run(Application.class);
    }

    @Bean
    public RestTemplate restTemplate(RestTemplateBuilder builder) {
        return builder.build();
    }

    @Bean
    public CommandLineRunner run(RestTemplate restTemplate) throws Exception {
        return args -> {
            Quote quote = restTemplate.getForObject( "https://gturnquist-quoters.cfapps.io/api/random", Quote.class);
            log.info(quote.toString());
        };
    }
}

總結

Apache的HttpClient組件可謂良心之做，細細的品味一下源碼能夠學到不少設計模式和比編碼規範。不過在閱讀源碼以前最好了解一下不一樣版本的HTTP協議，尤爲是HTTP協議的Keep-Alive模式。使用Keep-Alive模式（又稱持久鏈接、鏈接重用）時，Keep-Alive功能使客戶端到服 務器端的鏈接持續有效，當出現對服務器的後繼請求時，Keep-Alive功能避免了創建或者從新創建鏈接。這裏推薦一篇參考連接：https://www.jianshu.com/p/49551bda6619。

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程