Httpclient usa PoolingHttpClientConnectionManager, bloqueo de subprocesos, setSoTimeout

pregunta

Interfaz de llamada http de subprocesos múltiples, utilizando PoolingHttpClientConnectionManager, grupo de conexiones. El hilo se ha estado ejecutando y no se puede cerrar.

configuración y versión

httpcliente：4.5.12

RequestConfig configuración de httpclient

/**
	 * 配置信息
	 * @param isProxy 是否代理
	 * @return RequestConfig requestConfig
	 */
	public   RequestConfig getRequestConfig(Boolean isProxy,Integer sockTimeout) {
		if(isProxy) {
			return RequestConfig.custom()
					.setSocketTimeout(sockTimeout)
					.setConnectTimeout(5000)
					.setProxy(new HttpHost(proxyHost, proxyPort ))
					.setConnectionRequestTimeout(5000)
					.build();
		}else {
			return	RequestConfig.custom()
					.setSocketTimeout(sockTimeout)
					.setConnectTimeout(1000)
					.setConnectionRequestTimeout(1000)
					.build();
		}
	}

Información de configuración de PoolingHttpClientConnectionManager

	private static final PoolingHttpClientConnectionManager HTTP_CLIENT_POOL = new PoolingHttpClientConnectionManager();

	static {
		HTTP_CLIENT_POOL.setMaxTotal(5000);
		HTTP_CLIENT_POOL.setDefaultMaxPerRoute(500);

	}

analizar problema

 Imprimir información del hilo

 

código correspondiente

private boolean createTunnelToTarget(
            final AuthState proxyAuthState,
            final HttpClientConnection managedConn,
            final HttpRoute route,
            final HttpRequest request,
            final HttpClientContext context) throws HttpException, IOException {

        final RequestConfig config = context.getRequestConfig();
        final int timeout = config.getConnectTimeout();

        final HttpHost target = route.getTargetHost();
        final HttpHost proxy = route.getProxyHost();
        HttpResponse response = null;

        final String authority = target.toHostString();
        final HttpRequest connect = new BasicHttpRequest("CONNECT", authority, request.getProtocolVersion());

        this.requestExecutor.preProcess(connect, this.proxyHttpProcessor, context);

        while (response == null) {
            if (!managedConn.isOpen()) {
                this.connManager.connect(
                        managedConn,
                        route,
                        timeout > 0 ? timeout : 0,
                        context);
            }

            connect.removeHeaders(AUTH.PROXY_AUTH_RESP);
            this.authenticator.generateAuthResponse(connect, proxyAuthState, context);

            response = this.requestExecutor.execute(connect, managedConn, context);
            this.requestExecutor.postProcess(response, this.proxyHttpProcessor, context);

            final int status = response.getStatusLine().getStatusCode();
            if (status < 200) {
                throw new HttpException("Unexpected response to CONNECT request: " +
                        response.getStatusLine());
            }

            if (config.isAuthenticationEnabled()) {
                if (this.authenticator.isAuthenticationRequested(proxy, response,
                        this.proxyAuthStrategy, proxyAuthState, context)) {
                    if (this.authenticator.handleAuthChallenge(proxy, response,
                            this.proxyAuthStrategy, proxyAuthState, context)) {
                        // Retry request
                        if (this.reuseStrategy.keepAlive(response, context)) {
                            this.log.debug("Connection kept alive");
                            // Consume response content
                            final HttpEntity entity = response.getEntity();
                            EntityUtils.consume(entity);
                        } else {
                            managedConn.close();
                        }
                        response = null;
                    }
                }
            }
        }

        final int status = response.getStatusLine().getStatusCode();

        if (status > 299) {

            // Buffer response content
            final HttpEntity entity = response.getEntity();
            if (entity != null) {
                response.setEntity(new BufferedHttpEntity(entity));
            }

            managedConn.close();
            throw new TunnelRefusedException("CONNECT refused by proxy: " +
                    response.getStatusLine(), response);
        }

        // How to decide on security of the tunnelled connection?
        // The socket factory knows only about the segment to the proxy.
        // Even if that is secure, the hop to the target may be insecure.
        // Leave it to derived classes, consider insecure by default here.
        return false;
    }

Tenga en cuenta el ciclo while.

En comparación con la configuración, se encuentra que el tiempo de espera de PoolingHttpClientConnectionManager no está configurado

Añadir PoolingHttpClientConnectionManager

Resolver el problema

PoolingHttpClientConnectionManager connPool = new PoolingHttpClientConnectionManager();
// 对连接池设置SocketConfig对象
connPool.setDefaultSocketConfig(SocketConfig.custom().setSoTimeout(10000).build());