Go并发HTTP请求中的错误处理与资源管理

package main

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

// HttpResponse 结构体用于承载HTTP请求的结果
type HttpResponse struct {
    URL      string
    Response *http.Response // 如果请求失败，此字段可能为nil
    Err      error          // 请求过程中遇到的错误
}

// fetchURL 执行单个HTTP GET请求，并将结果发送到通道
func fetchURL(url string, resultChan chan<- *HttpResponse) {
    resp, err := http.Get(url)
    if err != nil {
        // 如果发生错误，将错误信息通过通道返回，并将Response字段设为nil
        resultChan <- &HttpResponse{URL: url, Response: nil, Err: err}
        return // 立即返回，不再执行后续操作
    }

    // 确保在函数返回前关闭响应体，但只有在resp非nil时才执行
    // defer语句会在函数执行完毕前调用，保证资源释放
    defer func() {
        if resp != nil && resp.Body != nil {
            resp.Body.Close()
        }
    }()

    // 请求成功，将响应体和nil错误通过通道返回
    resultChan <- &HttpResponse{URL: url, Response: resp, Err: nil}
}

// asyncHttpGets 启动指定数量的协程并发地请求一组URL
func asyncHttpGets(targetURLs []string, numGoroutines int) []*HttpResponse {
    var wg sync.WaitGroup                                             // 用于等待所有协程完成
    resultChan := make(chan *HttpResponse, numGoroutines*len(targetURLs)) // 带缓冲的通道，避免阻塞

    // 启动指定数量的协程
    for i := 0; i < numGoroutines; i++ {
        wg.Add(1) // 每次启动一个协程，计数器加1
        go func() {
            defer wg.Done() // 协程结束时，计数器减1
            // 每个协程遍历目标URL列表，并执行请求
            for _, url := range targetURLs {
                fetchURL(url, resultChan)
            }
        }()
    }

    // 等待所有协程完成其工作
    wg.Wait()
    close(resultChan) // 关闭通道，表示不再有数据写入

    // 从通道收集所有结果
    responses := make([]*HttpResponse, 0, numGoroutines*len(targetURLs))
    for r := range resultChan {
        responses = append(responses, r)
    }
    return responses
}

func main() {
    // 示例URL列表
    urls := []string{
        "http://site-centos-64:8080/examples/abc1.jsp",
        // 可以添加更多URL进行测试，例如：
        // "https://www.google.com",
        // "http://nonexistent.domain", // 用于测试错误情况
    }
    const numGoroutines = 1000 // 并发协程数量

    fmt.Printf("启动 %d 个协程，请求 %d 个URL...\n", numGoroutines, len(urls))

    startTime := time.Now()
    results := asyncHttpGets(urls, numGoroutines)
    elapsedTime := time.Since(startTime)

    fmt.Printf("完成 %d 个结果的获取，耗时 %s。\n", len(results), elapsedTime)

    successCount := 0
    errorCount := 0

    // 遍历并处理所有结果
    for _, result := range results {
        if result.Err != nil {
            // 如果有错误，打印错误信息
            fmt.Printf("URL: %s, 错误: %v\n", result.URL, result.Err)
            errorCount++
        } else {
            // 如果没有错误，才安全地访问Response字段
            fmt.Printf("URL: %s, 状态: %s\n", result.URL, result.Response.Status)
            successCount++
        }
    }
    fmt.Printf("\n总结: 成功 %d 个，失败 %d 个。\n", successCount, errorCount)
}

    defer func() {
        if resp != nil && resp.Body != nil { // 确保resp和resp.Body都非nil
            resp.Body.Close()
        }
    }()

    for _, result := range results {
        if result.Err != nil {
            // 如果有错误，打印错误信息
            fmt.Printf("URL: %s, 错误: %v\n", result.URL, result.Err)
            errorCount++
        } else {
            // 如果没有错误，才安全地访问Response字段及其属性
            fmt.Printf("URL: %s, 状态: %s\n", result.URL, result.Response.Status)
            successCount++
        }
    }