Go并发HTTP请求中的nil指针恐慌：深入理解错误处理与资源管理

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}
    }
}

// ...
fmt.Printf("%s status: %s\n", result.url,
    result.response.Status) // 如果 result.response 为 nil，此处将引发 panic
// ...

package main

import (
    "fmt"
    "net/http"
    "sync" // 引入 sync 包
    "time" // 引入 time 包用于设置超时
)

// HttpResponse 结构体，用于封装HTTP请求结果
type HttpResponse struct {
    URL      string
    Response *http.Response // 即使有错误，也可能需要传递 nil
    Err      error
}

// 定义一个带缓冲的通道，用于收集所有协程的结果
var ch = make(chan *HttpResponse, 1000)

// fetchURL 执行单个HTTP请求并处理错误
func fetchURL(url string, wg *sync.WaitGroup) {
    defer wg.Done() // 确保协程完成时通知 WaitGroup

    // 创建一个自定义的 HTTP 客户端，设置超时
    client := &http.Client{
        Timeout: 10 * time.Second, // 设置请求超时时间
    }

    resp, err := client.Get(url) // 使用自定义客户端
    if err != nil {
        // 如果发生错误，直接将错误信息发送到通道，response 为 nil
        ch <- &HttpResponse{URL: url, Response: nil, Err: err}
        return // 发生错误后立即返回
    }

    // 确保在函数返回前关闭响应体
    // defer 语句确保 resp.Body.Close() 在函数结束时执行，即使发生其他错误
    defer func() {
        if resp != nil && resp.Body != nil { // 双重检查，确保不会对 nil 执行 Close
            resp.Body.Close()
        }
    }()

    // 如果没有错误，将响应和 nil 错误发送到通道
    ch <- &HttpResponse{URL: url, Response: resp, Err: nil}
}

// asyncHttpGets 异步执行多个HTTP请求
func asyncHttpGets(urls []string) []*HttpResponse {
    var wg sync.WaitGroup // 声明 WaitGroup
    responses := make([]*HttpResponse, 0, len(urls)) // 预分配切片容量

    for _, url := range urls {
        wg.Add(1) // 为每个协程增加计数
        go fetchURL(url, &wg) // 启动协程，传入 WaitGroup
    }

    // 启动一个独立的 Goroutine 来等待所有协程完成，然后关闭通道
    go func() {
        wg.Wait() // 等待所有 fetchURL 协程完成
        close(ch) // 所有发送者都已完成，关闭通道
    }()

    // 从通道收集结果，直到通道关闭
    for r := range ch {
        responses = append(responses, r)
    }

    return responses
}

package main

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

// 定义需要轮询的URL列表
var urls = []string{
    "http://site-centos-64:8080/examples/abc1.jsp", // 假设这是一个可能失败的URL
    "http://www.google.com",                       // 一个通常成功的URL
    "http://invalid.domain.xyz",                   // 一个必然失败的URL
}

// HttpResponse 结构体，用于封装HTTP请求结果
type HttpResponse struct {
    URL      string
    Response *http.Response // 如果请求失败，此字段可能为 nil
    Err      error
}

// 定义一个带缓冲的通道，用于收集所有协程的结果
// 缓冲大小可以根据并发量和处理速度进行调整
var ch = make(chan *HttpResponse, len(urls)*2) // 示例中缓冲设置为 URL 数量的两倍

// fetchURL 执行单个HTTP请求并处理错误
func fetchURL(url string, wg *sync.WaitGroup) {
    defer wg.Done() // 确保协程完成时通知 WaitGroup

    // 创建一个自定义的 HTTP 客户端，设置超时
    // 建议在外部创建并复用 http.Client 实例，而不是在每个协程中创建
    client := &http.Client{
        Timeout: 5 * time.Second, // 设置请求超时时间
    }

    resp, err := client.Get(url)
    if err != nil {
        // 如果发生错误，直接将错误信息发送到通道，Response 字段为 nil
        ch <- &HttpResponse{URL: url, Response: nil, Err: err}
        return // 发生错误后立即返回
    }

    // 使用 defer 确保在函数返回前关闭响应体
    // 即使后续处理发生错误，Body 也会被关闭
    defer func() {
        if resp != nil && resp.Body != nil {
            resp.Body.Close()
        }
    }()

    // 如果没有错误，将响应和 nil 错误发送到通道
    ch <- &HttpResponse{URL: url, Response: resp, Err: nil}
}

// asyncHttpGets 异步执行多个HTTP请求，并收集所有结果
func asyncHttpGets(urls []string) []*HttpResponse {
    var wg sync.WaitGroup // 声明 WaitGroup
    // 预分配切片容量，避免多次扩容
    responses := make([]*HttpResponse, 0, len(urls))

    for _, url := range urls {
        wg.Add(1)             // 为每个协程增加计数
        go fetchURL(url, &wg) // 启动协程，传入 WaitGroup
    }

    // 启动一个独立的 Goroutine 来等待所有协程完成，然后关闭通道
    go func() {
        wg.Wait() // 等待所有 fetchURL 协程完成
        close(ch) // 所有发送者都已完成，关闭通道
    }()

    // 从通道收集结果，直到通道关闭
    for r := range ch {
        responses = append(responses, r)
    }

    return responses
}

func main() {
    fmt.Println("开始异步HTTP请求...")
    results := asyncHttpGets(urls)
    fmt.Println("所有请求完成，正在处理结果：")

    for _, result := range results {
        if result.Err != nil {
            // 处理错误情况
            fmt.Printf("URL: %s, 错误: %v\n", result.URL, result.Err)
        } else {
            // 处理成功情况
            // 在访问 result.Response 之前，已确保其不为 nil
            fmt.Printf("URL: %s, 状态: %s\n", result.URL, result.Response.Status)
        }
    }
    fmt.Println("程序结束。")
}