Go并发HTTP请求中的nil指针解引用与健壮错误处理

func Get(url string) (resp *Response, err error)

resp, err := http.Get(url)
resp.Body.Close() // 潜在的nil指针解引用
ch <- &HttpResponse{url, resp, err} // 将nil的resp传递到channel

package main

import (
    "fmt"
    "io" // 导入 io 包以处理 body.Close()
    "net/http"
    "sync"
    "time" // 用于模拟实际的网站响应时间或超时
)

// HttpResponse 结构体用于承载请求结果
type HttpResponse struct {
    url      string
    response *http.Response
    err      error
}

// 全局通道，用于收集所有 Goroutine 的结果
var ch = make(chan *HttpResponse, 1000) // 缓冲通道，防止阻塞

// worker 函数负责执行单个 HTTP 请求并处理错误
func worker(url string, ch chan<- *HttpResponse) {
    resp, err := http.Get(url)
    if err != nil {
        // 如果发生错误，resp将是nil。
        // 将错误信息发送到通道，response字段保持nil。
        ch <- &HttpResponse{url: url, response: nil, err: err}
        return // 立即返回，不再尝试操作nil的resp
    }

    // 请求成功，resp不为nil。确保在函数退出前关闭响应体。
    // 使用 defer 可以保证无论函数如何退出，都会执行此操作。
    defer func() {
        if resp != nil && resp.Body != nil {
            io.Copy(io.Discard, resp.Body) // 确保读取并丢弃所有剩余数据
            resp.Body.Close()
        }
    }()

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

// asyncHttpGets 函数协调并发HTTP请求
func asyncHttpGets(urls []string, numRequests int) []*HttpResponse {
    responses := make([]*HttpResponse, 0, numRequests)

    // 确保有目标URL
    if len(urls) == 0 {
        return responses
    }
    targetURL := urls[0] // 根据原始代码的意图，假设我们针对第一个URL发起多次请求

    var wg sync.WaitGroup // 用于等待所有Goroutine完成

    // 启动 numRequests 个 Goroutine，每个 Goroutine 请求目标URL
    for i := 0; i < numRequests; i++ {
        wg.Add(1) // 增加WaitGroup计数器
        go func() {
            defer wg.Done() // Goroutine完成时减少计数器
            worker(targetURL, ch)
        }()
    }

    // 启动一个独立的Goroutine来等待所有worker完成并关闭通道
    go func() {
        wg.Wait()   // 等待所有worker Goroutine完成
        close(ch)   // 关闭通道，通知接收方不再有数据
    }()

    // 从通道收集所有响应，直到通道被关闭
    for r := range ch {
        responses = append(responses, r)
    }

    return responses
}

func main() {
    // 示例URL，可以根据需要修改
    var urls = []string{
        "http://site-centos-64:8080/examples/abc1.jsp", // 替换为你的实际测试URL
        // "http://nonexistent-domain-123.com", // 模拟一个会出错的URL
        // "http://localhost:9999", // 模拟一个连接拒绝的URL
    }

    const numConcurrentRequests = 1000 // 发起的并发请求数量

    fmt.Printf("开始对 %s 发起 %d 次并发请求...\n", urls[0], numConcurrentRequests)
    startTime := time.Now()

    results := asyncHttpGets(urls, numConcurrentRequests)

    duration := time.Since(startTime)
    fmt.Printf("所有请求完成，耗时: %v\n", duration)
    fmt.Printf("共收到 %d 个响应。\n", len(results))

    // 遍历并打印结果
    for i, result := range results {
        if result.err != nil {
            fmt.Printf("[%d] Error fetching %s: %v\n", i+1, result.url, result.err)
        } else {
            fmt.Printf("[%d] %s status: %s\n", i+1, result.url, result.response.Status)
        }
    }
}

func main() {
    // ... (前略) ...
    results := asyncHttpGets(urls, numConcurrentRequests)
    // ... (中略) ...

    for _, result := range results {
        if result.err != nil {
            fmt.Printf("Error fetching %s: %v\n", result.url, result.err)
        } else {
            // 只有当没有错误时，才访问 result.response
            fmt.Printf("%s status: %s\n", result.url, result.response.Status)
        }
    }
}