Go语言并发HTTP请求的错误处理与资源管理实践

// 原始代码片段
func abc(i int){
    for _, url := range urls {
        resp, err := http.Get(url) // 如果发生错误，resp将是nil
        resp.Body.Close()          // 此时如果resp为nil，会导致panic
        ch <- &HttpResponse{url, resp, err} // 将可能为nil的resp和错误发送到通道
    }
}

package main

import (
    "fmt"
    "io" // 导入io包用于处理Body的关闭
    "net/http"
    "sync" // 导入sync包用于等待所有goroutine完成
    "time" // 导入time包用于模拟等待
)

var urls = []string{
    "http://site-centos-64:8080/examples/abc1.jsp", // 假设这是一个有效的URL
    "http://nonexistent-domain.invalid",             // 模拟一个会失败的URL
    "http://localhost:9999",                         // 模拟一个可能连接不上的URL
}

// HttpResponse结构体用于封装每个请求的结果
type HttpResponse struct {
    URL      string
    Response *http.Response
    Err      error
}

// 使用缓冲通道来收集所有goroutine的结果
var ch = make(chan *HttpResponse, len(urls)*1000) // 根据实际并发数和URL数量调整通道大小

// 使用WaitGroup来等待所有goroutine完成
var wg sync.WaitGroup

// abc函数现在负责处理单个URL的HTTP请求，并正确处理错误
func abc(url string) {
    defer wg.Done() // 确保goroutine完成时通知WaitGroup

    resp, err := http.Get(url)

    // 核心改进：先检查错误
    if err != nil {
        // 如果发生错误，将错误信息和nil的Response发送到通道
        ch <- &HttpResponse{URL: url, Response: nil, Err: err}
        return // 提前返回，避免访问nil的resp
    }

    // 如果请求成功，使用defer确保Body关闭
    // 即使resp不为nil，其Body也可能在某些情况下为nil，但对于成功的http.Get通常不会
    // 稳妥起见，可以再次检查resp.Body是否为nil
    defer func() {
        if resp != nil && resp.Body != nil {
            io.Copy(io.Discard, resp.Body) // 读取并丢弃所有Body内容，确保连接复用
            resp.Body.Close()
        }
    }()

    // 将成功的响应发送到通道
    ch <- &HttpResponse{URL: url, Response: resp, Err: nil}
}

// asyncHttpGets函数启动多个goroutine并行处理HTTP请求
func asyncHttpGets(targetURLs []string, concurrency int) []*HttpResponse {
    // 确保并发数不会超过URL数量，或设置一个合理的上限
    if concurrency <= 0 {
        concurrency = 1 // 至少一个并发
    }
    if concurrency > len(targetURLs) {
        concurrency = len(targetURLs)
    }

    // 模拟原始代码的1000次迭代，但更合理的方式是针对每个URL启动一个goroutine
    // 这里我们假设要对每个URL请求1000次，或者总共发起1000个请求，每个请求一个URL
    // 鉴于原始问题中的循环结构，我们假设是针对每个URL，发起多个请求。
    // 但更常见的场景是针对一组URL，每个URL请求一次。
    // 为了贴合原始问题意图，我们仍然使用一个外部循环来控制总请求次数。

    totalRequests := 1000 // 假设总共发起1000次请求
    if len(targetURLs) == 0 {
        return []*HttpResponse{}
    }

    // 使用一个信号量来控制并发数
    sem := make(chan struct{}, concurrency)

    for i := 0; i < totalRequests; i++ {
        sem <- struct{}{} // 获取一个令牌，控制并发
        wg.Add(1)
        go func(url string) {
            defer func() { <-sem }() // 释放令牌
            abc(url)
        }(targetURLs[i%len(targetURLs)]) // 循环使用URL列表
    }

    wg.Wait()      // 等待所有goroutine完成
    close(ch)      // 关闭通道，表示没有更多数据写入
    close(sem)     // 关闭信号量通道

    responses := []*HttpResponse{}
    for r := range ch { // 从通道中读取所有结果
        responses = append(responses, r)
    }
    return responses
}

func main() {
    // 设定并发数，例如100
    const maxConcurrency = 100
    fmt.Printf("开始异步HTTP请求，总请求数：%d，并发数：%d\n", 1000, maxConcurrency)
    startTime := time.Now()

    results := asyncHttpGets(urls, maxConcurrency)

    elapsedTime := time.Since(startTime)
    fmt.Printf("所有请求完成，耗时：%s\n", elapsedTime)

    for _, result := range results {
        if result.Err != nil {
            // 处理错误情况
            fmt.Printf("URL: %s 失败，错误: %v\n", result.URL, result.Err)
        } else {
            // 处理成功情况，确保result.Response不为nil
            if result.Response != nil {
                fmt.Printf("URL: %s 状态码: %s\n", result.URL, result.Response.Status)
            } else {
                // 理论上不会发生，因为Err为nil时Response应该非nil
                fmt.Printf("URL: %s 状态码: (未知，Response为nil但无错误)\n", result.URL)
            }
        }
    }
}