最近在做Druid大資料實時分析系統，以Http的方式向Druid叢集寫入資料，採用HttpClient向叢集提交資料，由於資料量較大，採用多執行緒的方式開啟了10個執行緒後，發現單個的HttpClient會出現連線超時，效率不高，所以想用到連線池的方式提高效率下面是一個簡單的HttpClient連線池的實現：

package com.ssm.httpclient.utils;

import java.io.IOException;
import java.util.concurrent.TimeUnit;

import org.apache.http.client.config.RequestConfig
 
;
import org.apache.http.config.Registry;
import org.apache.http.config.RegistryBuilder;
import org.apache.http.config.SocketConfig;
import org.apache.http.conn.DnsResolver;
import org.apache.http.conn.HttpConnectionFactory;
import org.apache.http.conn.ManagedHttpClientConnection;
import org.apache.http
 
.conn.routing.HttpRoute;
import org.apache.http.conn.socket.ConnectionSocketFactory;
import org.apache.http.conn.socket.PlainConnectionSocketFactory;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.impl.DefaultConnectionReuseStrategy;
import org.apache.http.impl.client
 
.CloseableHttpClient;
import org.apache.http.impl.client.DefaultConnectionKeepAliveStrategy;
import org.apache.http.impl.client.DefaultHttpRequestRetryHandler;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.impl.conn.DefaultHttpResponseParserFactory;
import org.apache.http.impl.conn.ManagedHttpClientConnectionFactory;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.apache.http.impl.conn.SystemDefaultDnsResolver;
import org.apache.http.impl.io.DefaultHttpRequestWriterFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class HttpClientUtils {

    private static final Logger LOG = LoggerFactory.getLogger(HttpClientUtils.class);

    static PoolingHttpClientConnectionManager manager = null;
    static CloseableHttpClient httpClient = null;

    public static synchronized CloseableHttpClient getHttpClient(){

        if(httpClient == null){

            //註冊訪問協議相關的Socket工廠         
            Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder.<ConnectionSocketFactory>create()
                    .register("http", PlainConnectionSocketFactory.INSTANCE)
                    .register("https", SSLConnectionSocketFactory.getSystemSocketFactory())
                    .build();

            //HttpConnection 工廠:配置寫請求/解析響應處理器
            HttpConnectionFactory<HttpRoute, ManagedHttpClientConnection> connectionFactory
              = new ManagedHttpClientConnectionFactory(DefaultHttpRequestWriterFactory.INSTANCE, 
                    DefaultHttpResponseParserFactory.INSTANCE);

            //DNS 解析器
            DnsResolver dnsResolver = SystemDefaultDnsResolver.INSTANCE;

            //建立池化連線管理器
            manager = new PoolingHttpClientConnectionManager(socketFactoryRegistry,connectionFactory,dnsResolver);

            //預設為Socket配置
            SocketConfig defaultSocketConfig = SocketConfig.custom().setTcpNoDelay(true).build();
            manager.setDefaultSocketConfig(defaultSocketConfig);

            manager.setMaxTotal(300); //設定整個連線池的最大連線數
            //每個路由的預設最大連線，每個路由實際最大連線數由DefaultMaxPerRoute控制，而MaxTotal是整個池子的最大數
            //設定過小無法支援大併發(ConnectionPoolTimeoutException) Timeout waiting for connection from pool
            manager.setDefaultMaxPerRoute(200);//每個路由的最大連線數
            //在從連線池獲取連線時，連線不活躍多長時間後需要進行一次驗證，預設為2s
            manager.setValidateAfterInactivity(5*1000);

            //預設請求配置

            RequestConfig defaultRequestConfig = RequestConfig.custom()
                    .setConnectTimeout(2*1000) //設定連線超時時間，2s
                    .setSocketTimeout(5*1000) //設定等待資料超時時間，5s
                    .setConnectionRequestTimeout(2000) //設定從連線池獲取連線的等待超時時間
                    .build();

            //建立HttpClient
            httpClient = HttpClients.custom()
                    .setConnectionManager(manager)
                    .setConnectionManagerShared(false) //連線池不是共享模式
                    .evictIdleConnections(60, TimeUnit.SECONDS) //定期回收空閒連線
                    .evictExpiredConnections()// 定期回收過期連線
                    .setConnectionTimeToLive(60, TimeUnit.SECONDS) //連線存活時間，如果不設定，則根據長連線資訊決定
                    .setDefaultRequestConfig(defaultRequestConfig) //設定預設請求配置
                    .setConnectionReuseStrategy(DefaultConnectionReuseStrategy.INSTANCE) //連線重用策略，即是否能keepAlive
                    .setKeepAliveStrategy(DefaultConnectionKeepAliveStrategy.INSTANCE) //長連線配置，即獲取長連線生產多長時間
                    .setRetryHandler(new DefaultHttpRequestRetryHandler(0, false)) //設定重試次數，預設是3次，當前是禁用掉（根據需要開啟）
                    .build();


            //JVM 停止或重啟時，關閉連線池釋放掉連線(跟資料庫連線池類似)

            Runtime.getRuntime().addShutdownHook(new Thread(){

                @Override
                public void run() {

                    try{
                        if(httpClient !=null){
                            httpClient.close();
                        }
                    }catch(IOException e){
                        LOG.error("error when close httpClient:{}",e);
                    }

                }

            });

        }

        return httpClient;
    }

}

基於HttpClientUtils的測試

package com.ssm.httpclient.utils;

import java.io.IOException;
import java.nio.charset.Charset;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.ThreadFactory;

import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.util.EntityUtils;

import com.google.common.collect.Lists;
import com.google.common.util.concurrent.ThreadFactoryBuilder;

public class HttpClientExample {

    public static void main(String[] args) {

        final ThreadFactory threadFactory = new ThreadFactoryBuilder()
        .setNameFormat("Orders-%d").build();

        ExecutorService executorService = Executors.newFixedThreadPool(10,threadFactory);

        List<Future<?>> list = Lists.newArrayList();

        Long startTime = System.currentTimeMillis();

        Future<?> future;
        for(int i=0;i<100;i++){
            future = executorService.submit((new HttpGetTest()));
            list.add(future);
        }

        for(Future<?> future2:list){
            try {
                future2.get();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }

        System.out.println("total cost times: "+(System.currentTimeMillis()-startTime));

        executorService.shutdown();
    }

}

class HttpGetTest implements Runnable {

    public void run() {

        HttpResponse response = null;

        try {

            HttpGet get = new HttpGet("https://baike.baidu.com/item/httpclient/5766483?fr=aladdin");

            response = HttpClientUtils.getHttpClient().execute(get);

            if (response.getStatusLine().getStatusCode() != HttpStatus.SC_OK) {
                EntityUtils.consume(response.getEntity());
            } else {
                String result = EntityUtils.toString(response.getEntity(),Charset.forName("utf-8"));
                System.out.println(result);
            }

        } catch (Exception e) {
            if (response != null) {
                try {
                    EntityUtils.consume(response.getEntity());
                } catch (IOException e1) {
                    e1.printStackTrace();
                }
            }
        }

    }

}

total cost times: 3248

一百個執行緒請求花了3s 多，效能還是可以