Golang负载测试程序在Windows中耗尽端口问题

这个问题是由于Windows的TCP连接处理方式与Linux不同导致的。在Windows上，当连接关闭后，端口会进入TIME_WAIT状态，导致端口耗尽。以下是解决方案：

1. 使用连接池和KeepAlive：

func caller(arg args, c chan bool) {
    // 创建可复用的HTTP客户端
    tr := &http.Transport{
        MaxIdleConns:        arg.threads,
        MaxIdleConnsPerHost: arg.threads,
        IdleConnTimeout:     30 * time.Second,
        DisableKeepAlives:   false, // 启用KeepAlive
    }
    
    client := &http.Client{
        Transport: tr,
        Timeout:   10 * time.Second,
    }

    r, err := client.Post(arg.url, "application/json", bytes.NewReader(arg.body))
    
    if err != nil {
        c <- false
        return
    }
    defer r.Body.Close()

    _, err = ioutil.ReadAll(r.Body)
    if err != nil {
        c <- false
        return
    }

    c <- true
}

1. 使用单个共享的HTTP客户端：

var client *http.Client
var clientOnce sync.Once

func getClient(threads int) *http.Client {
    clientOnce.Do(func() {
        tr := &http.Transport{
            MaxIdleConns:        threads,
            MaxIdleConnsPerHost: threads,
            IdleConnTimeout:     30 * time.Second,
            DisableKeepAlives:   false,
        }
        client = &http.Client{
            Transport: tr,
            Timeout:   10 * time.Second,
        }
    })
    return client
}

func caller(arg args, c chan bool) {
    client := getClient(arg.threads)
    
    r, err := client.Post(arg.url, "application/json", bytes.NewReader(arg.body))
    
    if err != nil {
        c <- false
        return
    }
    defer r.Body.Close()

    _, err = ioutil.ReadAll(r.Body)
    if err != nil {
        c <- false
        return
    }

    c <- true
}

1. 使用SO_REUSEADDR选项（需要syscall）：

import (
    "syscall"
    "golang.org/x/sys/windows"
)

func dialerWithReuseAddr(network, addr string) (net.Conn, error) {
    dialer := &net.Dialer{
        Control: func(network, address string, c syscall.RawConn) error {
            var operr error
            err := c.Control(func(fd uintptr) {
                operr = windows.SetsockoptInt(windows.Handle(fd), windows.SOL_SOCKET, windows.SO_REUSEADDR, 1)
            })
            if err != nil {
                return err
            }
            return operr
        },
    }
    return dialer.Dial(network, addr)
}

func caller(arg args, c chan bool) {
    tr := &http.Transport{
        DialContext: func(ctx context.Context, network, addr string) (net.Conn, error) {
            return dialerWithReuseAddr(network, addr)
        },
        MaxIdleConns:        arg.threads,
        MaxIdleConnsPerHost: arg.threads,
        DisableKeepAlives:   false,
    }
    
    client := &http.Client{Transport: tr}
    
    r, err := client.Post(arg.url, "application/json", bytes.NewReader(arg.body))
    
    if err != nil {
        c <- false
        return
    }
    defer r.Body.Close()

    _, err = ioutil.ReadAll(r.Body)
    if err != nil {
        c <- false
        return
    }

    c <- true
}

1. 限制并发连接数并添加延迟：

func parallel(arg args) chan bool {
    out := make(chan bool)
    sem := make(chan struct{}, 1000) // 限制最大并发连接数
    
    for i := 0; i < arg.threads; i++ {
        go func() {
            sem <- struct{}{}
            caller(arg, out)
            <-sem
        }()
    }
    
    return out
}

func caller(arg args, c chan bool) {
    time.Sleep(time.Millisecond * 10) // 添加微小延迟
    
    tr := &http.Transport{
        MaxIdleConns:        100,
        MaxIdleConnsPerHost: 100,
        DisableKeepAlives:   false,
    }
    
    client := &http.Client{Transport: tr}
    
    r, err := client.Post(arg.url, "application/json", bytes.NewReader(arg.body))
    
    if err != nil {
        c <- false
        return
    }
    defer r.Body.Close()

    _, err = ioutil.ReadAll(r.Body)
    if err != nil {
        c <- false
        return
    }

    c <- true
}

主要问题是你在代码中设置了DisableKeepAlives: true，这会导致每个请求都创建新的连接而不复用。Windows对TIME_WAIT状态的处理比Linux更严格，因此需要启用连接复用。