HttpClient连接池管理

HTTP连接管理器

管理连接和连接管理器
Http连接是复杂，有状态的，线程不安全的对象，所以它必须被妥善管理。一个Http连接在同一时间只能被一个线程访问。HttpClient使用一个叫做Http连接管理器的特殊实体类来管理Http连接，这个实体类要实现HttpClientConnectionManager接口。Http连接管理器在新建http连接时，作为工厂类;管理持久http连接的生命周期;同步持久连接（确保线程安全，即一个http连接同一时间只能被一个线程访问）。Http连接管理器和ManagedHttpClientConnection的实例类一起发挥作用，ManagedHttpClientConnection实体类可以看做http连接的一个代理服务器，管理着I/O操作。如果一个Http连接被释放或者被它的消费者明确表示要关闭，那么底层的连接就会和它的代理进行分离，并且该连接会被交还给连接管理器。这是，即使服务消费者仍然持有代理的引用，它也不能再执行I/O操作，或者更改Http连接的状态。

下面的代码展示了如何从连接管理器中取得一个http连接：

HttpClientContext context = HttpClientContext.create();  
HttpClientConnectionManager connMrg = new BasicHttpClientConnectionManager();  
HttpRoute route = new HttpRoute(new HttpHost("localhost", 80));  
// 获取新的连接. 这里可能耗费很多时间  
ConnectionRequest connRequest = connMrg.requestConnection(route, null);  
// 10秒超时  
HttpClientConnection conn = connRequest.get(10, TimeUnit.SECONDS);  
try {  
    // 如果创建连接失败  
    if (!conn.isOpen()) {  
        // establish connection based on its route info  
        connMrg.connect(conn, route, 1000, context);  
        // and mark it as route complete  
        connMrg.routeComplete(conn, route, context);  
    }  
     // 进行自己的操作.  
} finally {  
    connMrg.releaseConnection(conn, null, 1, TimeUnit.MINUTES);  
}  

如果要终止连接，可以调用ConnectionRequest的cancel()方法。这个方法会解锁被ConnectionRequest类get()方法阻塞的线程。

简单连接管理器
BasicHttpClientConnectionManager是个简单的连接管理器，它一次只能管理一个连接。尽管这个类是线程安全的，它在同一时间也只能被一个线程使用。BasicHttpClientConnectionManager会尽量重用旧的连接来发送后续的请求，并且使用相同的路由。如果后续请求的路由和旧连接中的路由不匹配，BasicHttpClientConnectionManager就会关闭当前连接，使用请求中的路由重新建立连接。如果当前的连接正在被占用，会抛出java.lang.IllegalStateException异常。

连接池管理器
相对BasicHttpClientConnectionManager来说，PoolingHttpClientConnectionManager是个更复杂的类，它管理着连接池，可以同时为很多线程提供http连接请求。Connections are pooled on a per route basis.当请求一个新的连接时，如果连接池有有可用的持久连接，连接管理器就会使用其中的一个，而不是再创建一个新的连接。

PoolingHttpClientConnectionManager维护的连接数在每个路由基础和总数上都有限制。默认，每个路由基础上的连接不超过2个，总连接数不能超过20。在实际应用中，这个限制可能会太小了，尤其是当服务器也使用Http协议时。

下面的例子演示了如果调整连接池的参数：

PoolingHttpClientConnectionManager cm = new PoolingHttpClientConnectionManager();  
// Increase max total connection to 200  
cm.setMaxTotal(200);  
// Increase default max connection per route to 20  
cm.setDefaultMaxPerRoute(20);  
// Increase max connections for localhost:80 to 50  
HttpHost localhost = new HttpHost("locahost", 80);  
cm.setMaxPerRoute(new HttpRoute(localhost), 50);  

CloseableHttpClient httpClient = HttpClients.custom()  
        .setConnectionManager(cm)  
        .build();  

关闭连接管理器
当一个HttpClient的实例不在使用，或者已经脱离它的作用范围，我们需要关掉它的连接管理器，来关闭掉所有的连接，释放掉这些连接占用的系统资源。

CloseableHttpClient httpClient = <...>  
httpClient.close();  

多线程请求执行

当使用了请求连接池管理器（比如PoolingClientConnectionManager）后，HttpClient就可以同时执行多个线程的请求了。

PoolingClientConnectionManager会根据它的配置来分配请求连接。如果连接池中的所有连接都被占用了，那么后续的请求就会被阻塞，直到有连接被释放回连接池中。为了防止永远阻塞的情况发生，我们可以把http.conn-manager.timeout的值设置成一个整数。如果在超时时间内，没有可用连接，就会抛出ConnectionPoolTimeoutException异常。

PoolingHttpClientConnectionManager cm = new PoolingHttpClientConnectionManager();  
CloseableHttpClient httpClient = HttpClients.custom()  
        .setConnectionManager(cm)  
        .build();  

// URIs to perform GETs on  
String[] urisToGet = {  
    "http://www.domain1.com/",  
    "http://www.domain2.com/",  
    "http://www.domain3.com/",  
    "http://www.domain4.com/"  
};  

// create a thread for each URI  
GetThread[] threads = new GetThread[urisToGet.length];  
for (int i = 0; i < threads.length; i++) {  
    HttpGet httpget = new HttpGet(urisToGet[i]);  
    threads[i] = new GetThread(httpClient, httpget);  
}  

// start the threads  
for (int j = 0; j < threads.length; j++) {  
    threads[j].start();  
}  

// join the threads  
for (int j = 0; j < threads.length; j++) {  
    threads[j].join();  
}  

即使HttpClient的实例是线程安全的，可以被多个线程共享访问，但是仍旧推荐每个线程都要有自己专用实例的HttpContext。

下面是GetThread类的定义：

static class GetThread extends Thread {  

    private final CloseableHttpClient httpClient;  
    private final HttpContext context;  
    private final HttpGet httpget;  

    public GetThread(CloseableHttpClient httpClient, HttpGet httpget) {  
        this.httpClient = httpClient;  
        this.context = HttpClientContext.create();  
        this.httpget = httpget;  
    }  

    @Override  
    public void run() {  
        try {  
            CloseableHttpResponse response = httpClient.execute(  
                    httpget, context);  
            try {  
                HttpEntity entity = response.getEntity();  
            } finally {  
                response.close();  
            }  
        } catch (ClientProtocolException ex) {  
            // Handle protocol errors  
        } catch (IOException ex) {  
            // Handle I/O errors  
        }  
    }  

}  

连接回收策略

经典阻塞I/O模型的一个主要缺点就是只有当组侧I/O时，socket才能对I/O事件做出反应。当连接被管理器收回后，这个连接仍然存活，但是却无法监控socket的状态，也无法对I/O事件做出反馈。如果连接被服务器端关闭了，客户端监测不到连接的状态变化（也就无法根据连接状态的变化，关闭本地的socket）。

HttpClient为了缓解这一问题造成的影响，会在使用某个连接前，监测这个连接是否已经过时，如果服务器端关闭了连接，那么连接就会失效。这种过时检查并不是100%有效，并且会给每个请求增加10到30毫秒额外开销。唯一一个可行的，且does not involve a one thread per socket model for idle connections的解决办法，是建立一个监控线程，来专门回收由于长时间不活动而被判定为失效的连接。这个监控线程可以周期性的调用ClientConnectionManager类的closeExpiredConnections()方法来关闭过期的连接，回收连接池中被关闭的连接。它也可以选择性的调用ClientConnectionManager类的closeIdleConnections()方法来关闭一段时间内不活动的连接。

public static class IdleConnectionMonitorThread extends Thread {  

    private final HttpClientConnectionManager connMgr;  
    private volatile boolean shutdown;  

    public IdleConnectionMonitorThread(HttpClientConnectionManager connMgr) {  
        super();  
        this.connMgr = connMgr;  
    }  

    @Override  
    public void run() {  
        try {  
            while (!shutdown) {  
                synchronized (this) {  
                    wait(5000);  
                    // Close expired connections  
                    connMgr.closeExpiredConnections();  
                    // Optionally, close connections  
                    // that have been idle longer than 30 sec  
                    connMgr.closeIdleConnections(30, TimeUnit.SECONDS);  
                }  
            }  
        } catch (InterruptedException ex) {  
            // terminate  
        }  
    }  

    public void shutdown() {  
        shutdown = true;  
        synchronized (this) {  
            notifyAll();  
        }  
    }  

}  

连接存活策略

Http规范没有规定一个持久连接应该保持存活多久。有些Http服务器使用非标准的Keep-Alive头消息和客户端进行交互，服务器端会保持数秒时间内保持连接。HttpClient也会利用这个头消息。如果服务器返回的响应中没有包含Keep-Alive头消息，HttpClient会认为这个连接可以永远保持。然而，很多服务器都会在不通知客户端的情况下，关闭一定时间内不活动的连接，来节省服务器资源。在某些情况下默认的策略显得太乐观，我们可能需要自定义连接存活策略。

ConnectionKeepAliveStrategy myStrategy = new ConnectionKeepAliveStrategy() {  

    public long getKeepAliveDuration(HttpResponse response, HttpContext context) {  
        // Honor 'keep-alive' header  
        HeaderElementIterator it = new BasicHeaderElementIterator(  
                response.headerIterator(HTTP.CONN_KEEP_ALIVE));  
        while (it.hasNext()) {  
            HeaderElement he = it.nextElement();  
            String param = he.getName();  
            String value = he.getValue();  
            if (value != null && param.equalsIgnoreCase("timeout")) {  
                try {  
                    return Long.parseLong(value) * 1000;  
                } catch(NumberFormatException ignore) {  
                }  
            }  
        }  
        HttpHost target = (HttpHost) context.getAttribute(  
                HttpClientContext.HTTP_TARGET_HOST);  
        if ("www.naughty-server.com".equalsIgnoreCase(target.getHostName())) {  
            // Keep alive for 5 seconds only  
            return 5 * 1000;  
        } else {  
            // otherwise keep alive for 30 seconds  
            return 30 * 1000;  
        }  
    }  

};  
CloseableHttpClient client = HttpClients.custom()  
        .setKeepAliveStrategy(myStrategy)  
        .build();  

socket连接工厂

Http连接使用java.net.Socket类来传输数据。这依赖于ConnectionSocketFactory接口来创建、初始化和连接socket。这样也就允许HttpClient的用户在代码运行时，指定socket初始化的代码。PlainConnectionSocketFactory是默认的创建、初始化明文socket（不加密）的工厂类。

创建socket和使用socket连接到目标主机这两个过程是分离的，所以我们可以在连接发生阻塞时，关闭socket连接。

HttpClientContext clientContext = HttpClientContext.create();  
PlainConnectionSocketFactory sf = PlainConnectionSocketFactory.getSocketFactory();  
Socket socket = sf.createSocket(clientContext);  
int timeout = 1000; //ms  
HttpHost target = new HttpHost("localhost");  
InetSocketAddress remoteAddress = new InetSocketAddress(  
        InetAddress.getByAddress(new byte[] {127,0,0,1}), 80);  
sf.connectSocket(timeout, socket, target, remoteAddress, null, clientContext);