Go HTTP连接池与端口耗尽问题深度解析

好的，我来帮你整理一个详细的博客，说明这个HTTP连接池和端口耗尽的问题。

Go HTTP连接池与端口耗尽问题深度解析

问题背景

在使用Go语言开发高并发应用时，经常会遇到这样的错误：

dial tcp 192.168.31.212:8545: connect: cannot assign requested address

这个错误通常发生在大量并发HTTP请求时，表面上看是网络连接问题，实际上是本地端口耗尽导致的。本文将深入分析这个问题的根本原因和解决方案。

问题现象

在压力测试场景中，当启动100个worker并发请求时：

// 日志显示
[Worker 61] 交易成功: 0xe88b728fdda58bc903d5a79eab0a634fe4b1ea74335e14ea1b455dfd85318ef5
[Worker 61] 交易成功: 0x4404ee2034c8de1f6602039979003f4a7341f611d8b205b0ec5066e7a7173c30
[Worker 61] 转账失败: [Worker 61] 检查发送方余额失败: Post "http://192.168.31.212:8545": dial tcp 192.168.31.212:8545: connect: cannot assign requested address

奇怪的是：Worker 61之前能正常交易，但后来却报连接错误。这说明问题不是连接本身，而是连接池管理的问题。

根本原因分析

1. HTTP连接池的工作机制

Go的http.Client底层使用连接池来复用TCP连接，但连接池有严格的限制：

// Go标准库默认配置
var DefaultTransport = &Transport{
    MaxIdleConns:          100,        // 最大空闲连接数
    MaxIdleConnsPerHost:   2,          // 每个主机最大空闲连接数 ← 关键限制！
    IdleConnTimeout:       90 * time.Second,  // 空闲连接超时
    TLSHandshakeTimeout:   10 * time.Second,
    ExpectContinueTimeout: 1 * time.Second,
}

2. 连接池耗尽的原因

当大量并发请求时：

1. 连接池被占满：每个主机的连接数限制为2个
2. 需要创建新连接：当连接池没有可用连接时
3. 新连接需要新端口：每个TCP连接需要唯一的本地端口
4. 本地端口耗尽：导致cannot assign requested address错误

代码调用流程分析

完整的调用链路

// 1. 你的应用代码
client, err := ethclient.Dial(rpcURL)
resp, err := client.TransactionReceipt(ctx, hash)

// 2. ethclient.Dial() 调用链
func Dial(rawurl string) (*Client, error) {
    return DialContext(context.Background(), rawurl)
}

func DialContext(ctx context.Context, rawurl string) (*Client, error) {
    c, err := rpc.DialContext(ctx, rawurl)  // 调用rpc包
    if err != nil {
        return nil, err
    }
    return NewClient(c), nil
}

// 3. rpc.DialContext() 调用链
func DialContext(ctx context.Context, rawurl string) (*Client, error) {
    return DialOptions(ctx, rawurl)
}

func DialOptions(ctx context.Context, rawurl string, options ...ClientOption) (*Client, error) {
    // ...
    switch u.Scheme {
    case "http", "https":
        reconnect = newClientTransportHTTP(rawurl, cfg)  // 关键调用！
    }
    return newClient(ctx, cfg, reconnect)
}

// 4. newClientTransportHTTP() 创建HTTP客户端
func newClientTransportHTTP(endpoint string, cfg *clientConfig) reconnectFunc {
    client := cfg.httpClient
    if client == nil {
        client = new(http.Client)  // 这里创建http.Client！
    }
    
    hc := &httpConn{
        client:  client,  // 使用创建的http.Client
        headers: headers,
        url:     endpoint,
        auth:    cfg.httpAuth,
        closeCh: make(chan interface{}),
    }
    // ...
}

// 5. 实际HTTP请求调用链
func (hc *httpConn) doRequest(ctx context.Context, msg interface{}) (io.ReadCloser, error) {
    // ...
    resp, err := hc.client.Do(req)  // 调用http.Client.Do()
    // ...
}

// 6. http.Client.Do() 内部调用
func (c *Client) do(req *Request) (retres *Response, reterr error) {
    // ...
    if resp, didTimeout, err = c.send(req, deadline); err != nil {
        // ...
    }
    // ...
}

// 7. c.send() 调用Transport
func send(ireq *Request, rt RoundTripper, deadline time.Time) (resp *Response, didTimeout func() bool, err error) {
    // ...
    resp, err = rt.RoundTrip(req)  // 这里调用Transport.RoundTrip()
    // ...
}

// 8. Transport.RoundTrip() 中会尝试获取连接
// 如果没有可用连接，会创建新连接 ← 这里可能报错！

关键代码位置

// 文件：/Users/jayzhan/go/pkg/mod/github.com/ethereum/go-ethereum@v1.16.2/rpc/http.go:154
client = new(http.Client)  // 每个worker创建独立的http.Client

// 文件：/Users/jayzhan/go/pkg/mod/github.com/ethereum/go-ethereum@v1.16.2/rpc/http.go:229
resp, err := hc.client.Do(req)  // 发送HTTP请求

// 文件：/usr/local/go/src/net/http/client.go:720
if resp, didTimeout, err = c.send(req, deadline); err != nil {

// 文件：/usr/local/go/src/net/http/client.go:258
resp, err = rt.RoundTrip(req)  // 这里会尝试获取连接

问题复现场景

场景1：连接数超限

// 你有100个worker，每个worker的http.Client默认配置：
MaxIdleConnsPerHost: 2  // 每个主机最多2个空闲连接

// 当并发请求超过2个时：
// 请求1: 使用连接1
// 请求2: 使用连接2  
// 请求3: 连接池已满，需要创建新连接 ← 这里会报错！

场景2：连接超时

// 连接空闲90秒后自动关闭
IdleConnTimeout: 90 * time.Second

// 如果连接空闲超过90秒，下次请求时需要创建新连接

场景3：连接被服务器关闭

// 服务器可能因为各种原因关闭连接：
// - 负载均衡
// - 超时设置
// - 连接数限制
// - 网络问题

解决方案

方案1：自定义HTTP客户端配置

// 创建自定义HTTP传输层，优化连接池
httpClient := &http.Client{
    Transport: &http.Transport{
        MaxIdleConns:        1000,              // 最大空闲连接数
        MaxIdleConnsPerHost: 100,               // 每个主机的最大空闲连接数
        IdleConnTimeout:     90 * time.Second,  // 空闲连接超时
        DisableCompression:  true,              // 禁用压缩以提高性能
        DisableKeepAlives:   false,             // 启用Keep-Alive
    },
    Timeout: 30 * time.Second, // 请求超时
}

// 使用自定义HTTP客户端
client, err := ethclient.DialHTTPWithClient(rpcURL, httpClient)

方案2：共享HTTP客户端

// 全局共享一个HTTP客户端，避免创建过多实例
var globalHTTPClient = &http.Client{
    Transport: &http.Transport{
        MaxIdleConns:        1000,
        MaxIdleConnsPerHost: 100,
        IdleConnTimeout:     90 * time.Second,
    },
}

// 在NewWorker中使用
func NewWorker(id int, sender *User, rpcURL string, wg *sync.WaitGroup) *Worker {
    client, err := ethclient.DialHTTPWithClient(rpcURL, globalHTTPClient)
    // ...
}

方案3：减少并发数量

// 减少worker数量
worker_count: 50  // 从100减少到50

// 或者分批启动worker
func (wm *WorkerManager) StartWorkers() {
    batchSize := 10 // 每批启动10个worker
    
    for i := 0; i < totalWorkers; i += batchSize {
        // 启动一批worker
        // ...
        time.Sleep(1 * time.Second) // 每批之间休息1秒
    }
}

方案4：系统级优化

#!/bin/bash
# 增加本地端口范围
echo "net.ipv4.ip_local_port_range = 1024 65535" | sudo tee -a /etc/sysctl.conf

# 优化TIME_WAIT重用
echo "net.ipv4.tcp_tw_reuse = 1" | sudo tee -a /etc/sysctl.conf
echo "net.ipv4.tcp_fin_timeout = 30" | sudo tee -a /etc/sysctl.conf

# 增加文件描述符限制
echo "* soft nofile 65536" | sudo tee -a /etc/security/limits.conf
echo "* hard nofile 65536" | sudo tee -a /etc/security/limits.conf

# 应用配置
sudo sysctl -p

方案5：添加重试机制

// 为关键操作添加重试机制
func (tm *TransferManager) checkBalance(address common.Address) (*big.Int, error) {
    var balance *big.Int
    var err error
    
    for retry := 0; retry < 3; retry++ {
        balance, err = tm.client.BalanceAt(context.Background(), address, nil)
        if err == nil {
            return balance, nil
        }
        
        // 如果是连接错误，等待后重试
        if retry < 2 {
            time.Sleep(time.Duration(retry+1) * time.Second)
        }
    }
    
    return nil, err
}

最佳实践建议

1. 连接池配置原则

// 推荐的连接池配置
MaxIdleConns:        1000,              // 总连接数
MaxIdleConnsPerHost: 100,               // 每个主机连接数
IdleConnTimeout:     90 * time.Second,  // 空闲超时

2. 监控和诊断

// 添加连接池监控
func monitorConnectionPool(client *http.Client) {
    transport := client.Transport.(*http.Transport)
    
    // 定期检查连接池状态
    go func() {
        ticker := time.NewTicker(30 * time.Second)
        for range ticker.C {
            // 可以添加连接池状态日志
            log.Printf("连接池状态: MaxIdleConns=%d, MaxIdleConnsPerHost=%d", 
                transport.MaxIdleConns, transport.MaxIdleConnsPerHost)
        }
    }()
}

3. 错误处理策略

// 区分不同类型的连接错误
func handleConnectionError(err error) {
    if strings.Contains(err.Error(), "cannot assign requested address") {
        // 端口耗尽错误，需要系统级优化
        log.Error("端口耗尽，建议增加本地端口范围或减少并发数")
    } else if strings.Contains(err.Error(), "connection refused") {
        // 连接被拒绝，可能是服务器问题
        log.Error("连接被拒绝，检查服务器状态")
    } else {
        // 其他网络错误
        log.Error("网络连接错误:", err)
    }
}

总结

cannot assign requested address 错误的根本原因是：

1. HTTP连接池确实存在，但每个主机的连接数限制为2个
2. 大量并发时，连接池被占满，需要创建新连接
3. 创建新连接需要新的本地端口，但本地端口耗尽
4. 解决方案：优化连接池配置、减少并发数量、系统级优化

通过理解HTTP连接池的工作机制和正确的配置方法，可以有效避免这类问题，提高应用的稳定性和性能。