Go语言并发HTTP客户端异常排查与优化指南

package main

import (
    "fmt"
    "net/http"
    "time"
)

// Result 结构体用于存储请求统计信息
type Result struct {
    successful int
    total      int
    timeouts   int
    errors     int
    duration   time.Duration
}

// makeRequests 函数负责发送指定数量的HTTP请求
func makeRequests(url string, messages int, resultChan chan<- *http.Response) {
    for i := 0; i < messages; i++ {
        resp, _ := http.Get(url) // 忽略错误
        if resp != nil {
            resultChan <- resp // 仅在响应不为nil时发送
        }
    }
}

// deployRequests 部署并发请求并收集结果
func deployRequests(url string, threads int, messages int) *Result {
    results := new(Result)
    resultChan := make(chan *http.Response) // 无缓冲通道
    start := time.Now()

    // 启动多个goroutine发送请求
    for i := 0; i < threads; i++ {
        // 简单分配请求数量，可能导致总数不精确
        go makeRequests(url, (messages/threads)+1, resultChan)
    }

    // 从通道收集结果
    for response := range resultChan { // 循环直到通道关闭
        if response.StatusCode != 200 {
            results.errors += 1
        } else {
            results.successful += 1
        }
        results.total += 1
        if results.total == messages { // 依赖总数达到预期来终止
            return results
        }
    }
    results.duration = time.Since(start) // 记录总耗时
    return results
}

func main() {
    results := deployRequests("http://www.google.com", 10, 1000)
    fmt.Printf("Total: %d\n", results.total)
    fmt.Printf("Successful: %d\n", results.successful)
    fmt.Printf("Error: %d\n", results.errors)
    fmt.Printf("Timeouts: %d\n", results.timeouts)
    fmt.Printf("Duration: %s\n", results.duration)
}

package main

import (
    "context"
    "fmt"
    "net/http"
    "sync"
    "time"
)

// Result 结构体用于存储请求统计信息
type Result struct {
    successful int
    total      int
    timeouts   int
    errors     int
    duration   time.Duration
}

// RequestOutcome 代表每个请求的结果，包含响应或错误
type RequestOutcome struct {
    Response *http.Response
    Error    error
    IsTimeout bool
}

// makeRequests 函数负责发送指定数量的HTTP请求，并处理错误和超时
func makeRequests(ctx context.Context, url string, count int, resultChan chan<- *RequestOutcome, wg *sync.WaitGroup) {
    defer wg.Done() // 确保goroutine完成时调用Done

    for i := 0; i < count; i++ {
        req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
        if err != nil {
            resultChan <- &RequestOutcome{Error: err}
            continue
        }

        client := &http.Client{} // 每次请求使用新的client或复用一个
        resp, err := client.Do(req)

        if err != nil {
            // 检查是否是上下文超时错误
            if ctx.Err() == context.DeadlineExceeded {
                resultChan <- &RequestOutcome{Error: err, IsTimeout: true}
            } else {
                resultChan <- &RequestOutcome{Error: err}
            }
        } else {
            // 确保关闭响应体
            defer resp.Body.Close()
            resultChan <- &RequestOutcome{Response: resp}
        }
    }
}

// deployRequests 部署并发请求并收集结果
func deployRequests(url string, threads int, messages int, timeout time.Duration) *Result {
    results := new(Result)
    resultChan := make(chan *RequestOutcome, messages) // 使用带缓冲的通道，避免发送方阻塞
    var wg sync.WaitGroup
    start := time.Now()

    // 创建带超时的上下文
    ctx, cancel := context.WithTimeout(context.Background(), timeout)
    defer cancel() // 确保上下文被取消，释放资源

    // 优化请求分配
    requestsPerThread := messages / threads
    remainder := messages % threads

    for i := 0; i < threads; i++ {
        currentThreadRequests := requestsPerThread
        if i < remainder {
            currentThreadRequests++ // 前 'remainder' 个线程多处理一个请求
        }
        if currentThreadRequests == 0 && messages > 0 { // 避免启动无任务的goroutine，除非总任务为0
            continue
        }
        wg.Add(1)
        go makeRequests(ctx, url, currentThreadRequests, resultChan, &wg)
    }

    // 启动一个goroutine等待所有工作goroutine完成并关闭通道
    go func() {
        wg.Wait()
        close(resultChan) // 所有生产者完成后关闭通道
    }()

    // 从通道收集结果
    for outcome := range resultChan {
        results.total += 1
        if outcome.Error != nil {
            results.errors += 1
            if outcome.IsTimeout {
                results.timeouts += 1
            }
        } else if outcome.Response.StatusCode != http.StatusOK {
            results.errors += 1
        } else {
            results.successful += 1
        }
    }

    results.duration = time.Since(start)
    return results
}

func main() {
    // 设置总超时，例如10秒
    totalTimeout := 10 * time.Second
    results := deployRequests("http://www.google.com", 10, 1000, totalTimeout)
    fmt.Printf("Total: %d\n", results.total)
    fmt.Printf("Successful: %d\n", results.successful)
    fmt.Printf("Error: %d\n", results.errors)
    fmt.Printf("Timeouts: %d\n", results.timeouts)
    fmt.Printf("Duration: %s\n", results.duration)
}