HTTP 长连接与心跳机制

Connection: keep-alive
Keep-Alive: timeout=5, max=100

<!-- server.xml -->
<Connector port="8080" protocol="HTTP/1.1"
           connectionTimeout="20000"
           keepAliveTimeout="60000"
           maxKeepAliveRequests="100" />

http {
    keepalive_timeout  65;    # 空闲超时(秒)
    keepalive_requests 100;   # 最大请求数
}

server:
  tomcat:
    connection-timeout: 20000  # 连接超时(毫秒)
    keep-alive-timeout: 60000  # Keep-Alive 超时(毫秒)
    max-keep-alive-requests: 100  # 最大请求数

# 查看 TCP Keepalive 参数
cat /proc/sys/net/ipv4/tcp_keepalive_time    # 空闲多久开始发送探测(秒,默认7200)
cat /proc/sys/net/ipv4/tcp_keepalive_intvl   # 探测间隔(秒,默认75)
cat /proc/sys/net/ipv4/tcp_keepalive_probes  # 探测次数(默认9)

# 修改配置(临时)
echo 600 > /proc/sys/net/ipv4/tcp_keepalive_time
echo 30 > /proc/sys/net/ipv4/tcp_keepalive_intvl
echo 3 > /proc/sys/net/ipv4/tcp_keepalive_probes

Socket socket = new Socket();
socket.setKeepAlive(true);  // 开启 TCP Keepalive

import org.apache.hc.client5.http.config.RequestConfig;
import org.apache.hc.client5.http.impl.classic.CloseableHttpClient;
import org.apache.hc.client5.http.impl.classic.HttpClients;
import org.apache.hc.client5.http.impl.io.PoolingHttpClientConnectionManager;
import org.apache.hc.client5.http.impl.io.PoolingHttpClientConnectionManagerBuilder;
import org.apache.hc.core5.http.HttpHost;
import org.apache.hc.core5.util.TimeValue;
import org.apache.hc.core5.util.Timeout;

import java.util.concurrent.TimeUnit;

public class HttpClientFactory {

    public static CloseableHttpClient createClient() {
        // 请求配置
        RequestConfig requestConfig = RequestConfig.custom()
                .setConnectionRequestTimeout(Timeout.ofSeconds(2))  // 获取连接超时
                .setConnectTimeout(Timeout.ofSeconds(3))            // 建立连接超时
                .setResponseTimeout(Timeout.ofSeconds(5))           // 响应超时
                .build();

        // 连接池配置
        PoolingHttpClientConnectionManager connectionManager = PoolingHttpClientConnectionManagerBuilder.create()
                .setMaxConnTotal(200)           // 最大总连接数
                .setMaxConnPerRoute(50)         // 单路由最大连接数
                .setValidateAfterInactivity(TimeValue.ofSeconds(10))  // 空闲多久后验证连接
                .build();

        return HttpClients.custom()
                .setConnectionManager(connectionManager)
                .setDefaultRequestConfig(requestConfig)
                // 定期清理空闲连接(后台线程)
                .evictIdleConnections(TimeValue.ofSeconds(30))
                // 开启后台清理线程
                .evictExpiredConnections()
                .build();
    }

    // 为特定服务配置独立路由
    public static CloseableHttpClient createClientWithCustomRoute() {
        PoolingHttpClientConnectionManager connectionManager = PoolingHttpClientConnectionManagerBuilder.create()
                .setMaxConnTotal(200)
                .setMaxConnPerRoute(20)
                .build();

        // 为特定服务设置更大的连接数
        HttpHost customHost = new HttpHost("http", "api.example.com", 8080);
        connectionManager.setMaxPerRoute(customHost, 100);

        return HttpClients.custom()
                .setConnectionManager(connectionManager)
                .build();
    }
}

// 三个超时的含义不同,线上排障时经常被混淆

// 1. connectionRequestTimeout:等待连接池中连接的超时
//    - 连接池满了,等待其他请求释放连接
//    - 超时后抛出 ConnectionPoolTimeoutException

// 2. connectTimeout:建立 TCP 连接的超时
//    - 三次握手的时间
//    - 网络不通、服务端未启动时会超时
//    - 超时后抛出 ConnectTimeoutException

// 3. responseTimeout:连接建立后等待响应的超时
//    - 等待服务端返回数据的时间
//    - 包括服务端处理时间
//    - 超时后抛出 SocketTimeoutException

import org.apache.hc.client5.http.classic.methods.HttpGet;
import org.apache.hc.client5.http.impl.classic.CloseableHttpClient;
import org.apache.hc.core5.http.ClassicHttpResponse;
import org.apache.hc.core5.http.io.entity.EntityUtils;

public class HttpClientExample {

    public static void main(String[] args) throws Exception {
        try (CloseableHttpClient httpClient = HttpClientFactory.createClient()) {
            HttpGet request = new HttpGet("http://localhost:8080/api/users");

            httpClient.execute(request, response -> {
                System.out.println("响应状态:" + response.getCode());
                String body = EntityUtils.toString(response.getEntity());
                System.out.println("响应内容:" + body);
                return null;
            });
        }
    }
}

import okhttp3.ConnectionPool;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;

import java.util.concurrent.TimeUnit;

public class OkHttpExample {

    public static void main(String[] args) {
        OkHttpClient client = new OkHttpClient.Builder()
                .connectionPool(new ConnectionPool(50, 5, TimeUnit.MINUTES))
                .connectTimeout(3, TimeUnit.SECONDS)      // 连接超时
                .readTimeout(5, TimeUnit.SECONDS)         // 读取超时
                .writeTimeout(5, TimeUnit.SECONDS)        // 写入超时
                .retryOnConnectionFailure(true)           // 连接失败自动重试
                .build();

        Request request = new Request.Builder()
                .url("http://localhost:8080/api/users")
                .build();

        try (Response response = client.newCall(request).execute()) {
            System.out.println("响应状态:" + response.code());
            System.out.println("响应内容:" + response.body().string());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

// ConnectionPool(50, 5, TimeUnit.MINUTES)
// - 50: 最大空闲连接数
// - 5: 空闲连接存活时间
// - TimeUnit.MINUTES: 时间单位

// OkHttp 自动清理空闲连接,无需手动管理

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;

public class Java11HttpClientExample {

    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newBuilder()
                .connectTimeout(Duration.ofSeconds(3))  // 连接超时
                .version(HttpClient.Version.HTTP_2)      // 优先使用 HTTP/2
                .build();

        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("http://localhost:8080/api/users"))
                .timeout(Duration.ofSeconds(5))          // 请求超时
                .GET()
                .build();

        HttpResponse<String> response = client.send(
                request,
                HttpResponse.BodyHandlers.ofString()
        );

        System.out.println("响应状态:" + response.statusCode());
        System.out.println("响应内容:" + response.body());
    }
}

// PoolingHttpClientConnectionManager 内部逻辑(简化版)
public void connect(CPoolEntry entry) {
    // 获取连接的空闲时间
    long idleTime = System.currentTimeMillis() - entry.getLastUsedTime();

    // 如果空闲时间超过 validateAfterInactivity,则验证连接
    if (validateAfterInactivity > 0 && idleTime > validateAfterInactivity) {
        // 验证连接是否仍然有效
        boolean valid = entry.getConnection().isStale();
        if (valid) {
            // 连接已失效,关闭并重建
            entry.closeConnection();
            // 重新建立连接
            establishConnection(entry);
        }
        // 连接有效,直接使用
    }
    // 如果空闲时间未超过阈值,直接使用(不验证,性能更优)
}

// 推荐配置:10-30 秒
// 过短:每次获取连接都验证,增加延迟
// 过长:可能使用已失效的连接
PoolingHttpClientConnectionManagerBuilder.create()
    .setValidateAfterInactivity(TimeValue.ofSeconds(10))  // 空闲 10 秒后验证
    .build();

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;
import io.netty.handler.timeout.IdleStateEvent;
import io.netty.handler.timeout.IdleStateHandler;

import java.util.concurrent.TimeUnit;

public class WebSocketHeartbeatServer {

    public static void main(String[] args) throws Exception {
        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        EventLoopGroup workerGroup = new NioEventLoopGroup();

        try {
            ServerBootstrap bootstrap = new ServerBootstrap();
            bootstrap.group(bossGroup, workerGroup)
                    .channel(NioServerSocketChannel.class)
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) {
                            ChannelPipeline pipeline = ch.pipeline();

                            // 空闲检测:60秒未读取数据触发空闲事件
                            pipeline.addLast(new IdleStateHandler(60, 0, 0, TimeUnit.SECONDS));

                            // 编解码器
                            pipeline.addLast(new StringDecoder());
                            pipeline.addLast(new StringEncoder());

                            // 业务处理器
                            pipeline.addLast(new HeartbeatHandler());
                        }
                    });

            ChannelFuture future = bootstrap.bind(8080).sync();
            System.out.println("WebSocket 服务端已启动,端口:8080");
            future.channel().closeFuture().sync();
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}

// 心跳处理器
class HeartbeatHandler extends ChannelInboundHandlerAdapter {

    private static final String PING = "PING";
    private static final String PONG = "PONG";

    @Override
    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
        if (evt instanceof IdleStateEvent) {
            IdleStateEvent event = (IdleStateEvent) evt;
            if (event.state() == IdleState.READER_IDLE) {
                System.out.println("连接读空闲超时,关闭连接:" + ctx.channel().remoteAddress());
                ctx.close();
                return;
            }
        }
        super.userEventTriggered(ctx, evt);
    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        String message = (String) msg;

        // 处理心跳消息
        if (PING.equals(message)) {
            System.out.println("收到心跳:" + message);
            ctx.writeAndFlush(PONG);
            return;
        }

        // 处理业务消息
        System.out.println("收到业务消息:" + message);
        super.channelRead(ctx, msg);
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }
}

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;

import java.util.concurrent.TimeUnit;

public class WebSocketHeartbeatClient {

    private static final String PING = "PING";

    public static void main(String[] args) throws Exception {
        EventLoopGroup group = new NioEventLoopGroup();

        try {
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.group(group)
                    .channel(NioSocketChannel.class)
                    .handler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) {
                            ch.pipeline()
                                    .addLast(new StringDecoder())
                                    .addLast(new StringEncoder())
                                    .addLast(new ClientHandler());
                        }
                    });

            Channel channel = bootstrap.connect("localhost", 8080).sync().channel();
            System.out.println("已连接到服务端");

            // 定时发送心跳
            group.scheduleAtFixedRate(() -> {
                if (channel.isActive()) {
                    channel.writeAndFlush(PING);
                    System.out.println("发送心跳:" + PING);
                }
            }, 0, 30, TimeUnit.SECONDS);

            channel.closeFuture().sync();
        } finally {
            group.shutdownGracefully();
        }
    }
}

class ClientHandler extends ChannelInboundHandlerAdapter {

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        System.out.println("收到消息:" + msg);
    }

    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("连接断开,尝试重连...");
        // 实现重连逻辑
    }
}

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;

import java.util.concurrent.TimeUnit;

public class ReconnectingClient {

    private final String host;
    private final int port;
    private Bootstrap bootstrap;
    private Channel channel;
    private EventLoopGroup group;

    // 重连参数
    private int retryInterval = 5;  // 重连间隔(秒)
    private int maxRetries = 10;    // 最大重连次数
    private int retryCount = 0;

    public ReconnectingClient(String host, int port) {
        this.host = host;
        this.port = port;
    }

    public void start() throws Exception {
        group = new NioEventLoopGroup();

        bootstrap = new Bootstrap();
        bootstrap.group(group)
                .channel(NioSocketChannel.class)
                .handler(new ChannelInitializer<SocketChannel>() {
                    @Override
                    protected void initChannel(SocketChannel ch) {
                        ch.pipeline()
                                .addLast(new StringDecoder())
                                .addLast(new StringEncoder())
                                .addLast(new ReconnectHandler(ReconnectingClient.this));
                    }
                });

        connect();
    }

    public void connect() {
        if (retryCount >= maxRetries) {
            System.out.println("达到最大重连次数,停止重连");
            return;
        }

        System.out.println("尝试连接 " + host + ":" + port + " (第" + (retryCount + 1) + "次)");

        bootstrap.connect(host, port).addListener((ChannelFuture future) -> {
            if (future.isSuccess()) {
                System.out.println("连接成功");
                channel = future.channel();
                retryCount = 0;  // 重置重连计数
            } else {
                System.out.println("连接失败:" + future.cause().getMessage());
                retryCount++;

                // 延迟重连(指数退避)
                long delay = Math.min(retryInterval * (1L << Math.min(retryCount, 5)), 60);
                future.channel().eventLoop().schedule(() -> connect(), delay, TimeUnit.SECONDS);
            }
        });
    }

    public static void main(String[] args) throws Exception {
        ReconnectingClient client = new ReconnectingClient("localhost", 8080);
        client.start();
    }
}

class ReconnectHandler extends ChannelInboundHandlerAdapter {

    private final ReconnectingClient client;

    public ReconnectHandler(ReconnectingClient client) {
        this.client = client;
    }

    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("连接断开,尝试重连...");
        client.connect();
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }
}

// 1. 确认错误类型
// NoHttpResponseException 说明客户端尝试向已关闭的连接写数据
// 这意味着服务端已经关闭了连接,但客户端不知道

// 2. 检查服务端配置
// Tomcat keepAliveTimeout = 60s
// Nginx keepalive_timeout = 65s
// 客户端 evictIdleConnections 未配置!

// 3. 分析时间线
// 客户端获取连接 -> 空闲 70 秒 -> 再次使用
// 服务端 60 秒超时已关闭连接
// Nginx 65 秒超时已关闭连接
// 客户端复用旧连接 -> NoHttpResponseException

// 4. 解决方案
PoolingHttpClientConnectionManager connectionManager = PoolingHttpClientConnectionManagerBuilder.create()
        .setMaxConnTotal(200)
        .setMaxConnPerRoute(50)
        .setValidateAfterInactivity(TimeValue.ofSeconds(10))  // 使用前验证
        .build();

CloseableHttpClient httpClient = HttpClients.custom()
        .setConnectionManager(connectionManager)
        .evictIdleConnections(TimeValue.ofSeconds(30))  // 30 秒清理空闲连接
        .build();
// 空闲清理时间(30s) < 服务端超时(60s),确保连接在服务端关闭前被客户端主动回收

// 心跳参数配置
public class HeartbeatConfig {

    // 客户端心跳间隔
    // 必须小于中间设备(NAT/负载均衡器)的空闲超时
    // 负载均衡器空闲超时通常 90 秒,所以心跳设为 30 秒
    private static final int HEARTBEAT_INTERVAL = 30;  // 秒

    // 客户端断连判定
    // 连续 3 次心跳未响应则判定连接断开
    private static final int MAX_MISSED_HEARTBEATS = 3;

    // 服务端空闲超时
    // 应为心跳间隔的 2-3 倍,容忍 1-2 次心跳丢失
    private static final int SERVER_IDLE_TIMEOUT = 90;  // 秒

    // 重连参数
    // 指数退避:5, 10, 20, 40, 60, 60, 60...
    private static final int BASE_RETRY_INTERVAL = 5;   // 秒
    private static final int MAX_RETRY_INTERVAL = 60;   // 秒
    private static final int MAX_RETRY_COUNT = 100;     // 无限重连(但限流)
}

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.handler.timeout.IdleStateEvent;
import io.netty.handler.timeout.IdleState;

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicLong;

public class IMHeartbeatHandler extends ChannelInboundHandlerAdapter {

    // 连接活跃时间记录
    private static final ConcurrentHashMap<String, AtomicLong> lastActiveTime =
            new ConcurrentHashMap<>();

    @Override
    public void channelActive(ChannelHandlerContext ctx) {
        // 连接建立时记录活跃时间
        String channelId = ctx.channel().id().asLongText();
        lastActiveTime.put(channelId, new AtomicLong(System.currentTimeMillis()));
        System.out.println("连接建立:" + ctx.channel().remoteAddress());
    }

    @Override
    public void channelInactive(ChannelHandlerContext ctx) {
        // 连接断开时清理记录
        String channelId = ctx.channel().id().asLongText();
        lastActiveTime.remove(channelId);
        System.out.println("连接断开:" + ctx.channel().remoteAddress());
    }

    @Override
    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
        if (evt instanceof IdleStateEvent) {
            IdleStateEvent event = (IdleStateEvent) evt;
            if (event.state() == IdleState.READER_IDLE) {
                // 读空闲超时,说明客户端可能已断开
                System.out.println("读空闲超时,关闭僵尸连接:" + ctx.channel().remoteAddress());

                // 通知客户端连接即将关闭
                ctx.writeAndFlush("{\"type\":\"disconnect\",\"reason\":\"idle_timeout\"}");

                // 延迟 1 秒后关闭,确保通知消息能发出
                ctx.channel().eventLoop().schedule(() -> ctx.close(), 1, java.util.concurrent.TimeUnit.SECONDS);
                return;
            }
        }
        super.userEventTriggered(ctx, evt);
    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        // 更新活跃时间
        String channelId = ctx.channel().id().asLongText();
        AtomicLong time = lastActiveTime.get(channelId);
        if (time != null) {
            time.set(System.currentTimeMillis());
        }

        // 处理心跳
        if ("PING".equals(msg)) {
            ctx.writeAndFlush("PONG");
            return;
        }

        // 处理业务消息
        super.channelRead(ctx, msg);
    }
}

// 1. 检查连接池配置
PoolingHttpClientConnectionManager connectionManager =
    (PoolingHttpClientConnectionManager) httpClient.getConnectionManager();

System.out.println("总连接数:" + connectionManager.getTotalStats().getLeased());
System.out.println("最大连接数:" + connectionManager.getMaxTotal());
System.out.println("可用连接数:" + connectionManager.getTotalStats().getAvailable());

// 2. 检查超时配置
RequestConfig config = httpClient.getDefaultConfig().getRequestConfig();
System.out.println("获取连接超时:" + config.getConnectionRequestTimeout());
System.out.println("连接超时:" + config.getConnectTimeout());
System.out.println("响应超时:" + config.getResponseTimeout());

// 增加连接池大小
connectionManager.setMaxTotal(300);
connectionManager.setDefaultMaxPerRoute(100);

// 缩短超时时间,快速失败
RequestConfig requestConfig = RequestConfig.custom()
        .setConnectionRequestTimeout(Timeout.ofSeconds(1))
        .setConnectTimeout(Timeout.ofSeconds(2))
        .setResponseTimeout(Timeout.ofSeconds(3))
        .build();

// 定期清理空闲连接
httpClient = HttpClients.custom()
        .setConnectionManager(connectionManager)
        .setDefaultRequestConfig(requestConfig)
        .evictIdleConnections(TimeValue.ofSeconds(30))
        .build();

客户端心跳机制:
- 连接建立后启动心跳定时器
- 每 30 秒发送一次心跳
- 3 次心跳未响应则认为连接断开,触发重连

服务端空闲检测:
- 记录每个连接的最后活跃时间
- 定时扫描所有连接
- 超过 60 秒未收到心跳则主动断开
- 断开前通知客户端

断线重连:
- 检测到连接断开后延迟 5 秒重连
- 重连失败则延迟加倍(5, 10, 20, 40...)
- 最大延迟 60 秒
- 重连成功后恢复心跳

http {
    # 连接超时配置
    keepalive_timeout  65;    # 保持连接超时(秒)
    keepalive_requests 100;   # 最大请求数
    send_timeout 60;          # 响应超时

    # 代理超时配置
    proxy_connect_timeout 30;  # 代理连接超时
    proxy_read_timeout 60;     # 代理读取超时
    proxy_send_timeout 60;     # 代理发送超时

    # 代理 Keep-Alive
    proxy_http_version 1.1;
    proxy_set_header Connection "";

    upstream backend {
        server 127.0.0.1:8080;
        keepalive 50;  # 保留 50 个空闲连接
    }
}

问题:偶发"第一次请求失败,重试成功"

原因:
1. 客户端连接池中的连接已失效(服务端或中间设备关闭)
2. Keep-Alive 超时设置不合理
3. 连接池未清理空闲连接

解决方案:
1. 客户端定期清理空闲连接
2. 使用前验证连接有效性
3. 失败后自动重试
4. 调整 Keep-Alive 超时时间

// 推荐的客户端配置
public class HttpClientBestPractice {

    public static CloseableHttpClient createHttpClient() {
        // 1. 连接池配置
        PoolingHttpClientConnectionManager connectionManager =
            PoolingHttpClientConnectionManagerBuilder.create()
                .setMaxConnTotal(200)              // 最大总连接数
                .setMaxConnPerRoute(50)             // 单路由最大连接数
                .setValidateAfterInactivity(TimeValue.ofSeconds(10))  // 空闲验证
                .build();

        // 2. 超时配置
        RequestConfig requestConfig = RequestConfig.custom()
                .setConnectionRequestTimeout(Timeout.ofSeconds(1))   // 获取连接超时
                .setConnectTimeout(Timeout.ofSeconds(3))             // 连接超时
                .setResponseTimeout(Timeout.ofSeconds(5))            // 响应超时
                .build();

        // 3. 重试配置
        HttpRequestRetryHandler retryHandler = (exception, executionCount, context) -> {
            if (executionCount > 3) {
                return false;  // 最多重试 3 次
            }
            if (exception instanceof org.apache.hc.core5.http.NoHttpResponseException) {
                return true;  // 连接已关闭,可以重试
            }
            if (exception instanceof java.net.SocketTimeoutException) {
                return false;  // 超时不重试
            }
            return false;
        };

        // 4. 构建 HttpClient
        return HttpClients.custom()
                .setConnectionManager(connectionManager)
                .setDefaultRequestConfig(requestConfig)
                .setRetryStrategy(new DefaultHttpRequestRetryStrategy(3, TimeValue.ofSeconds(1)))
                .evictIdleConnections(TimeValue.ofSeconds(30))  // 清理空闲连接
                .build();
    }
}

<Connector port="8080" protocol="HTTP/1.1"
           connectionTimeout="20000"           <!-- 连接超时 20 秒 -->
           keepAliveTimeout="60000"            <!-- Keep-Alive 超时 60 秒 -->
           maxKeepAliveRequests="100"          <!-- 最大请求数 100 -->
           maxThreads="200"                    <!-- 最大线程数 200 -->
           acceptCount="100"                   <!-- 等待队列长度 100 -->
           enableLookups="false"               <!-- 禁用 DNS 反查 -->
           compression="on"                    <!-- 开启压缩 -->
           compressionMinSize="2048" />        <!-- 压缩最小大小 -->

server:
  port: 8080
  tomcat:
    connection-timeout: 20000        # 连接超时(毫秒)
    keep-alive-timeout: 60000        # Keep-Alive 超时(毫秒)
    max-keep-alive-requests: 100     # 最大请求数
    threads:
      max: 200                       # 最大线程数
      min-spare: 10                  # 最小空闲线程数
    accept-count: 100                # 等待队列长度

// 监控连接池状态
PoolingHttpClientConnectionManager connectionManager = ...;

Set<HttpRoute> routes = connectionManager.getRoutes();
for (HttpRoute route : routes) {
    PoolStats stats = connectionManager.getStats(route);
    System.out.println("路由:" + route);
    System.out.println("  租用连接数:" + stats.getLeased());
    System.out.println("  可用连接数:" + stats.getAvailable());
    System.out.println("  等待连接数:" + stats.getPending());
}

PoolStats totalStats = connectionManager.getTotalStats();
System.out.println("总租用连接数:" + totalStats.getLeased());
System.out.println("总可用连接数:" + totalStats.getAvailable());
System.out.println("总等待连接数:" + totalStats.getPending());

// Spring Boot Actuator 监控
@RestController
public class MetricsController {

    @Autowired
    private MeterRegistry meterRegistry;

    @GetMapping("/metrics/http")
    public Map<String, Object> httpMetrics() {
        Map<String, Object> metrics = new HashMap<>();

        // 连接数指标
        metrics.put("http.server.requests.active",
            meterRegistry.get("http.server.requests.active").gauge().value());

        // 请求延迟
        metrics.put("http.server.requests",
            meterRegistry.get("http.server.requests").timer().mean());

        return metrics;
    }
}

// 检查是否是连接池问题
if (connectionManager.getTotalStats().getPending() > 0) {
    System.out.println("有线程在等待连接,可能是连接池耗尽");
}

// 检查是否是超时配置问题
RequestConfig config = ...;
if (config.getConnectionRequestTimeout().toSeconds() < 1) {
    System.out.println("获取连接超时时间太短");
}

// 检查是否是连接失效问题
if (exception instanceof NoHttpResponseException) {
    System.out.println("连接已失效,可能是服务端关闭了连接");
}

心跳间隔:30-60 秒
空闲超时:心跳间隔的 2-3 倍
最大重连次数:根据业务重要性设置
重连间隔:指数退避(5, 10, 20, 40...)

// 根据实际并发量设置
int maxTotal = 并发请求数 * 2;  // 总连接数
int maxPerRoute = 单服务并发请求数 * 2;  // 单路由连接数

// 示例:并发 100,QPS 1000,平均响应 100ms
// 并发连接数 ≈ QPS * 平均响应时间 = 1000 * 0.1 = 100
// 连接池大小 ≈ 并发连接数 * 2 = 200

// 检查连接池状态
PoolingHttpClientConnectionManager connectionManager = ...;
PoolStats stats = connectionManager.getTotalStats();

System.out.println("租用连接数:" + stats.getLeased());
System.out.println("可用连接数:" + stats.getAvailable());
System.out.println("等待连接数:" + stats.getPending());
System.out.println("最大连接数:" + connectionManager.getMaxTotal());

if (stats.getPending() > 0) {
    System.out.println("警告:有线程在等待连接!");
}

// 检查各路由的连接状态
for (HttpRoute route : connectionManager.getRoutes()) {
    PoolStats routeStats = connectionManager.getStats(route);
    System.out.println("路由:" + route);
    System.out.println("  可用连接:" + routeStats.getAvailable());
    System.out.println("  租用连接:" + routeStats.getLeased());
}

// 检查超时配置
RequestConfig config = httpClient.getDefaultConfig().getRequestConfig();

System.out.println("获取连接超时:" + config.getConnectionRequestTimeout());
System.out.println("连接超时:" + config.getConnectTimeout());
System.out.println("响应超时:" + config.getResponseTimeout());

// 建议:
// 获取连接超时:1-2 秒
// 连接超时:2-3 秒
// 响应超时:根据业务设置,建议 3-10 秒

# 查看服务端 Keep-Alive 配置
# Tomcat:查看 server.xml 中的 keepAliveTimeout
# Nginx:查看 nginx.conf 中的 keepalive_timeout

# 抓包分析
tcpdump -i eth0 port 8080 -w http.pcap
# 使用 Wireshark 分析是否有大量 TCP Keep-Alive 或 FIN 包

// 检查心跳配置
// 1. 心跳间隔是否合理(30-60 秒)
// 2. 空闲超时是否是心跳间隔的 2-3 倍
// 3. 是否有断线重连机制