关于java:高并发场景下的-HttpClient-优化QPS-大大提升

HttpClient 优化思路：

1. 池化
2. 长连贯
3. httpclient 和 httpget 复用
4. 正当的配置参数（最大并发申请数，各种超时工夫，重试次数）
5. 异步 6、多读源码

1. 背景

咱们有个业务，会调用其余部门提供的一个基于 http 的服务，日调用量在千万级别。应用了 httpclient 来实现业务。之前因为 qps 上不去，就看了一下业务代码，并做了一些优化，记录在这里。

先比照前后：优化之前，均匀执行工夫是 250ms；优化之后，均匀执行工夫是 80ms，升高了三分之二的耗费，容器不再动不动就报警线程耗尽了，清新~

2. 剖析

我的项目的原实现比拟粗略，就是每次申请时初始化一个 httpclient，生成一个 httpPost 对象，执行，而后从返回后果取出 entity，保留成一个字符串，最初显式敞开 response 和 client。咱们一点点剖析和优化：

2.1 httpclient 重复创立开销

httpclient 是一个线程平安的类，没有必要由每个线程在每次应用时创立，全局保留一个即可。

2.2 重复创立 tcp 连贯的开销

tcp 的三次握手与四次挥手两大裹脚布过程，对于高频次的申请来说，耗费切实太大。试想如果每次申请咱们须要破费 5ms 用于协商过程，那么对于 qps 为 100 的单零碎，1 秒钟咱们就要花 500ms 用于握手和挥手。又不是高级领导，咱们程序员就不要搞这么大做派了，改成 keep alive 形式以实现连贯复用！

2.3 反复缓存 entity 的开销

本来的逻辑里，应用了如下代码：

HttpEntity entity = httpResponse.getEntity();
String response = EntityUtils.toString(entity);

这里咱们相当于额定复制了一份 content 到一个字符串里，而本来的 httpResponse 依然保留了一份 content，须要被 consume 掉，在高并发且 content 十分大的状况下，会耗费大量内存。并且，咱们须要显式的敞开连贯，ugly。

3. 实现

按下面的剖析，咱们次要要做三件事：一是单例的 client，二是缓存的保活连贯，三是更好的解决返回后果。一就不说了，来说说二。

提到连贯缓存，很容易联想到数据库连接池。httpclient4 提供了一个 PoolingHttpClientConnectionManager 作为连接池。接下来咱们通过以下步骤来优化：

3.1 定义一个 keep alive strategy

对于 keep-alive，本文不开展阐明，只提一点，是否应用 keep-alive 要依据业务状况来定，它并不是灵丹妙药。还有一点，keep-alive 和 time_wait/close_wait 之间也有不少故事。

在本业务场景里，咱们相当于有多数固定客户端，长时间极高频次的拜访服务器，启用 keep-alive 十分适合

再多提一嘴，http 的 keep-alive 和 tcp 的 KEEPALIVE 不是一个货色。回到注释，定义一个 strategy 如下：

ConnectionKeepAliveStrategy myStrategy = new ConnectionKeepAliveStrategy() {
    @Override
    public long getKeepAliveDuration(HttpResponse response, HttpContext context) {
        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")) {return Long.parseLong(value) * 1000;
            }
        }
        return 60 * 1000;// 如果没有约定，则默认定义时长为 60s
    }
};

3.2 配置一个 PoolingHttpClientConnectionManager

PoolingHttpClientConnectionManager connectionManager = new PoolingHttpClientConnectionManager();
connectionManager.setMaxTotal(500);
connectionManager.setDefaultMaxPerRoute(50);// 例如默认每路由最高 50 并发，具体根据业务来定 

也能够针对每个路由设置并发数。

3.3 生成 httpclient

httpClient = HttpClients.custom()
    .setConnectionManager(connectionManager)
    .setKeepAliveStrategy(kaStrategy)
    .setDefaultRequestConfig(RequestConfig.custom().setStaleConnectionCheckEnabled(true).build())
    .build();

留神：应用 setStaleConnectionCheckEnabled 办法来逐出已被敞开的链接不被举荐。更好的形式是手动启用一个线程，定时运行 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();
        }
    }
    
}

3.4 应用 httpclient 执行 method 时升高开销

这里要留神的是，不要敞开 connection。

一种可行的获取内容的形式相似于，把 entity 里的货色复制一份：

res = EntityUtils.toString(response.getEntity(),"UTF-8");
EntityUtils.consume(response1.getEntity());

然而，更举荐的形式是定义一个 ResponseHandler，不便你我他，不再本人 catch 异样和敞开流。在此咱们能够看一下相干的源码：

public <T> T execute(final HttpHost target, final HttpRequest request,
            final ResponseHandler<? extends T> responseHandler, final HttpContext context)
            throws IOException, ClientProtocolException {Args.notNull(responseHandler, "Response handler");
 
        final HttpResponse response = execute(target, request, context);
 
        final T result;
        try {result = responseHandler.handleResponse(response);
        } catch (final Exception t) {final HttpEntity entity = response.getEntity();
            try {EntityUtils.consume(entity);
            } catch (final Exception t2) {
                // Log this exception. The original exception is more
                // important and will be thrown to the caller.
                this.log.warn("Error consuming content after an exception.", t2);
            }
            if (t instanceof RuntimeException) {throw (RuntimeException) t;
            }
            if (t instanceof IOException) {throw (IOException) t;
            }
            throw new UndeclaredThrowableException(t);
        }
 
        // Handling the response was successful. Ensure that the content has
        // been fully consumed.
        final HttpEntity entity = response.getEntity();
        EntityUtils.consume(entity);// 看这里看这里
        return result;
    }

能够看到，如果咱们应用 resultHandler 执行 execute 办法，会最终主动调用 consume 办法，而这个 consume 办法如下所示：

public static void consume(final HttpEntity entity) throws IOException {if (entity == null) {return;}
        if (entity.isStreaming()) {final InputStream instream = entity.getContent();
            if (instream != null) {instream.close();
            }
        }
    }

能够看到最终它敞开了输出流。

4. 其余

通过以上步骤，根本就实现了一个反对高并发的 httpclient 的写法，上面是一些额定的配置和揭示：

4.1 httpclient 的一些超时配置

CONNECTION_TIMEOUT 是连贯超时工夫，SO_TIMEOUT 是 socket 超时工夫，这两者是不同的。连贯超时工夫是发动申请前的等待时间；socket 超时工夫是期待数据的超时工夫。

HttpParams params = new BasicHttpParams();
// 设置连贯超时工夫
Integer CONNECTION_TIMEOUT = 2 * 1000; // 设置申请超时 2 秒钟 依据业务调整
Integer SO_TIMEOUT = 2 * 1000; // 设置期待数据超时工夫 2 秒钟 依据业务调整
 
// 定义了当从 ClientConnectionManager 中检索 ManagedClientConnection 实例时应用的毫秒级的超时工夫
// 这个参数冀望失去一个 java.lang.Long 类型的值。如果这个参数没有被设置，默认等于 CONNECTION_TIMEOUT，因而肯定要设置。Long CONN_MANAGER_TIMEOUT = 500L; // 在 httpclient4.2.3 中我记得它被改成了一个对象导致间接用 long 会报错，起初又改回来了
 
params.setIntParameter(CoreConnectionPNames.CONNECTION_TIMEOUT, CONNECTION_TIMEOUT);
params.setIntParameter(CoreConnectionPNames.SO_TIMEOUT, SO_TIMEOUT);
params.setLongParameter(ClientPNames.CONN_MANAGER_TIMEOUT, CONN_MANAGER_TIMEOUT);
// 在提交申请之前 测试连贯是否可用
params.setBooleanParameter(CoreConnectionPNames.STALE_CONNECTION_CHECK, true);
 
// 另外设置 http client 的重试次数，默认是 3 次；以后是禁用掉（如果我的项目量不到，这个默认即可）httpClient.setHttpRequestRetryHandler(new DefaultHttpRequestRetryHandler(0, false));

4.2 如果配置了 nginx 的话，nginx 也要设置面向两端的 keep-alive

当初的业务里，没有 nginx 的状况反而比拟稀少。nginx 默认和 client 端关上长连贯而和 server 端应用短链接。留神 client 端的 keepalive_timeout 和 keepalive_requests 参数，以及 upstream 端的 keepalive 参数设置，这三个参数的意义在此也不再赘述。

以上就是我的全副设置。通过这些设置，胜利地将本来每次申请 250ms 的耗时升高到了 80 左右，效果显著。

JAR 包如下：

<!-- httpclient -->
<dependency>
    <groupId>org.apache.httpcomponents</groupId>
    <artifactId>httpclient</artifactId>
    <version>4.5.6</version>
</dependency>

代码如下：

//Basic 认证
private static final CredentialsProvider credsProvider = new BasicCredentialsProvider();
//httpClient
private static final CloseableHttpClient httpclient;
//httpGet 办法
private static final HttpGet httpget;
//
private static final RequestConfig reqestConfig;
// 响应处理器
private static final ResponseHandler<String> responseHandler;
//jackson 解析工具
private static final ObjectMapper mapper = new ObjectMapper();
static {System.setProperty("http.maxConnections","50");
    System.setProperty("http.keepAlive", "true");
    // 设置 basic 校验
    credsProvider.setCredentials(new AuthScope(AuthScope.ANY_HOST, AuthScope.ANY_PORT, AuthScope.ANY_REALM),
            new UsernamePasswordCredentials("",""));
    // 创立 http 客户端
    httpclient = HttpClients.custom()
            .useSystemProperties()
            .setRetryHandler(new DefaultHttpRequestRetryHandler(3,true))
            .setDefaultCredentialsProvider(credsProvider)
            .build();
    // 初始化 httpGet
    httpget = new HttpGet();
    // 初始化 HTTP 申请配置
    reqestConfig = RequestConfig.custom()
            .setContentCompressionEnabled(true)
            .setSocketTimeout(100)
            .setAuthenticationEnabled(true)
            .setConnectionRequestTimeout(100)
            .setConnectTimeout(100).build();
    httpget.setConfig(reqestConfig);
    // 初始化 response 解析器
    responseHandler = new BasicResponseHandler();}
/*
 * 性能：返回响应
 * @author zhangdaquan
 * @date 2019/1/3 上午 11:19
 * @param [url]
 * @return org.apache.http.client.methods.CloseableHttpResponse
 * @exception
 */
public static String getResponse(String url) throws IOException {HttpGet get = new HttpGet(url);
    String response = httpclient.execute(get,responseHandler);
    return response;
}
 
/*
 * 性能：发送 http 申请，并用 net.sf.json 工具解析
 * @author zhangdaquan
 * @date 2018/8/15 下午 2:21
 * @param [url]
 * @return org.json.JSONObject
 * @exception
 */
public static JSONObject getUrl(String url) throws Exception{
    try {httpget.setURI(URI.create(url));
        String response = httpclient.execute(httpget,responseHandler);
        JSONObject json = JSONObject.fromObject(response);
        return json;
    } catch (IOException e) {e.printStackTrace();
    }
    return null;
}
/*
 * 性能：发送 http 申请，并用 jackson 工具解析
 * @author zhangdaquan
 * @date 2018/12/24 下午 2:58
 * @param [url]
 * @return com.fasterxml.jackson.databind.JsonNode
 * @exception
 */
public static JsonNode getUrl2(String url){
    try {httpget.setURI(URI.create(url));
        String response = httpclient.execute(httpget,responseHandler);
        JsonNode node = mapper.readTree(response);
        return node;
    } catch (IOException e) {e.printStackTrace();
    }
    return null;
}
/*
 * 性能：发送 http 申请，并用 fastjson 工具解析
 * @author zhangdaquan
 * @date 2018/12/24 下午 2:58
 * @param [url]
 * @return com.fasterxml.jackson.databind.JsonNode
 * @exception
 */
public static com.alibaba.fastjson.JSONObject getUrl3(String url){
    try {httpget.setURI(URI.create(url));
        String response = httpclient.execute(httpget,responseHandler);
        com.alibaba.fastjson.JSONObject jsonObject = com.alibaba.fastjson.JSONObject.parseObject(response);
        return jsonObject;
    } catch (IOException e) {e.printStackTrace();
    }
    return null;
}

原文：blog.csdn.net/u010285974/article/details/85696239

近期热文举荐：

1.1,000+ 道 Java 面试题及答案整顿 (2022 最新版)

2. 劲爆！Java 协程要来了。。。

3.Spring Boot 2.x 教程，太全了！

4. 别再写满屏的爆爆爆炸类了，试试装璜器模式，这才是优雅的形式！！

5.《Java 开发手册（嵩山版）》最新公布，速速下载！

感觉不错，别忘了顺手点赞 + 转发哦！