HttpClient 中的三个超时区别及连接定时清理

httpclient创建

两种方式：

CloseableHttpClient httpclient = HttpClients.createDefault();

CloseableHttpClient httpclient = HttpAsyncClients.custom().setDefaultRequestConfig(requestConfig).setConnectionManager(connManager).build();

默认配置 createDefault 和使用了 custom 连接池（文章最后的 HttpClientUtil）两种情况的区别，通过源码可以看到前者也创建了连接池，最大连接20个，单个 host最大2个，但是区别在于每次创建的 httpclient 都自己维护了自己的连接池，而 custom 连接池时所有 httpclient 共用同一个连接池，这是在 api 使用方面需要注意的地方，要避免每次请求新建连接池、关闭连接池，造成性能问题。

httpclient反复创建开销

httpclient是一个线程安全的类，没有必要由每个线程在每次使用时创建，全局保留一个即可。优先使用单例+连接池

反复创建tcp连接的开销

tcp的三次握手与四次挥手两大裹脚布过程，对于高频次的请求来说，消耗实在太大。试想如果每次请求我们需要花费5ms用于协商过程，那么对于qps为100的单系统，1秒钟我们就要花500ms用于握手和挥手。
持久连接有两种方式：HTTP/1.0+的Keep-Avlive与HTTP/1.1的默认持久连接.

三个超时

RequestConfig requestConfig = RequestConfig.custom()
                    .setConnectionRequestTimeout(config.connReqTimeout)   //从连接池中获取连接的超时时间
                            //与服务器连接超时时间：httpclient会创建一个异步线程用以创建socket连接，此处设置该socket的连接超时时间
                    .setConnectTimeout(config.connTimeout)
                    .setSocketTimeout(config.socketTimeout)               //socket读数据超时时间：从服务器获取响应数据的超时时间
                    .build();
            httpClient = HttpClientBuilder.create()
                    .setMaxConnTotal(config.maxConnTotal)                   //连接池中最大连接数
                            /**
                             * 分配给同一个route(路由)最大的并发连接数。
                             * route：运行环境机器 到 目标机器的一条线路。
                             * 举例来说，我们使用HttpClient的实现来分别请求 www.baidu.com 的资源和 www.bing.com 的资源那么他就会产生两个route。
                             */
                    .setMaxConnPerRoute(config.maxConnPerRoute)
                    .setDefaultRequestConfig(requestConfig)
                    .build();

三个超时时间详解：

• ConnectionRequestTimeout：从连接池中获取可用连接超时，HttpClient中的要用连接时尝试从连接池中获取，若是在等待了一定的时间后还没有获取到可用连接（比如连接池中没有空闲连接了）则会抛出获取连接超时异常。

• connectionTimeout：连接目标超时，指的是连接目标url的连接超时时间，即客服端发送请求到与目标url建立起连接的最大时间。如果在该时间范围内还没有建立起连接，则就抛出connectionTimeOut异常。

• socketTimeout ：等待响应超时（读取数据超时）， 连接上一个url后，获取response的返回等待时间 ，即在与目标url建立连接后，等待放回response的最大时间，在规定时间内没有返回响应的话就抛出SocketTimeout。

HttpClient清理过期连接

1. 在HttpClient4.4版本之前，在从连接池中获取重用连接的时候会检查下是否过期，过期则清理。之后的版本则不同，会有一个单独的线程来扫描连接池中的连接，发现有离最近一次使用超过设置的时间后，就会清理。默认的超时时间是2秒钟。
   HttpClientBuilder类：

    public final HttpClientBuilder evictExpiredConnections() {
        evictExpiredConnections = true;
        return this;
    }

public CloseableHttpClient build() {            //如果指定了要清理过期连接与空闲连接，才会启动清理线程，默认是不启动的
            if (evictExpiredConnections || evictIdleConnections) {　　　　　　　　　　//创造一个连接池的清理线程
                final IdleConnectionEvictor connectionEvictor = new IdleConnectionEvictor(cm,
                        maxIdleTime > 0 ? maxIdleTime : 10, maxIdleTimeUnit != null ? maxIdleTimeUnit : TimeUnit.SECONDS,
                        maxIdleTime, maxIdleTimeUnit);
                closeablesCopy.add(new Closeable() {
                    @Override
                    public void close() throws IOException {
                        connectionEvictor.shutdown();
                        try {
                            connectionEvictor.awaitTermination(1L, TimeUnit.SECONDS);
                        } catch (final InterruptedException interrupted) {
                            Thread.currentThread().interrupt();
                        }
                    }

                });　　　　　　　　　　//执行该清理线程
                connectionEvictor.start();
}

清理空闲连接：

public IdleConnectionEvictor(
            final HttpClientConnectionManager connectionManager,
            final ThreadFactory threadFactory,
            final long sleepTime, final TimeUnit sleepTimeUnit,
            final long maxIdleTime, final TimeUnit maxIdleTimeUnit) {
        this.connectionManager = Args.notNull(connectionManager, "Connection manager");
        this.threadFactory = threadFactory != null ? threadFactory : new DefaultThreadFactory();
        this.sleepTimeMs = sleepTimeUnit != null ? sleepTimeUnit.toMillis(sleepTime) : sleepTime;
        this.maxIdleTimeMs = maxIdleTimeUnit != null ? maxIdleTimeUnit.toMillis(maxIdleTime) : maxIdleTime;
        this.thread = this.threadFactory.newThread(new Runnable() {
            @Override
            public void run() {
                try {　　　　　　　　　　　　//死循环，线程一直执行
                    while (!Thread.currentThread().isInterrupted()) {　　　　　　　　　　　　　　//休息若干秒后执行，默认10秒
                        Thread.sleep(sleepTimeMs);　　　　　　　　　　　　　　 //清理过期连接
                        connectionManager.closeExpiredConnections();　　　　　　　　　　　　　　 //如果指定了最大空闲时间，则清理空闲连接
                        if (maxIdleTimeMs > 0) {
                            connectionManager.closeIdleConnections(maxIdleTimeMs, TimeUnit.MILLISECONDS);
                        }
                    }
                } catch (final Exception ex) {
                    exception = ex;
                }

            }
        });
    }

2. 异步HttpClient中没有自动清理设置，自行实现
   手动启用一个线程，定时运行closeExpiredConnections 和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();
        }
    }
    
}

Httpclient.close

httpclient.close 会彻底关闭连接池，以及其中所有连接，一般情况下，只有在关闭应用时调用以释放资源

封装通用的异步调用好处

• 微服务见调用方便，不用担心rest接口调用超时；
• 不必重复造轮子，代码实现时不用考虑异步接口的实现