使用Go语言实现高效的并行URL请求与超时控制

package main

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

// FetchResult 结构体用于存储每个URL的抓取结果
type FetchResult struct {
    URL     string
    Content string
    Error   error
}

// fetchURLInGoroutine 负责在一个goroutine中抓取单个URL，并处理超时
func fetchURLInGoroutine(ctx context.Context, url string, resultChan chan<- FetchResult) {
    // 创建一个HTTP客户端，这里我们不设置全局的Client.Timeout，而是使用context控制
    client := &http.Client{}

    req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
    if err != nil {
        resultChan <- FetchResult{URL: url, Error: fmt.Errorf("创建请求失败: %w", err)}
        return
    }

    resp, err := client.Do(req)
    if err != nil {
        // 检查是否是上下文取消导致的错误 (如超时)
        if ctx.Err() != nil {
            resultChan <- FetchResult{URL: url, Error: fmt.Errorf("请求 %s 因 %s 被取消", url, ctx.Err())}
        } else {
            resultChan <- FetchResult{URL: url, Error: fmt.Errorf("HTTP请求失败: %w", err)}
        }
        return
    }
    defer resp.Body.Close() // 确保关闭响应体

    if resp.StatusCode != http.StatusOK {
        resultChan <- FetchResult{URL: url, Error: fmt.Errorf("HTTP状态码非200: %d", resp.StatusCode)}
        return
    }

    bodyBytes, err := io.ReadAll(resp.Body)
    if err != nil {
        resultChan <- FetchResult{URL: url, Error: fmt.Errorf("读取响应体失败: %w", err)}
        return
    }

    resultChan <- FetchResult{URL: url, Content: string(bodyBytes)}
}

func main() {
    urls := []string{
        "https://www.google.com",
        "https://www.baidu.com",
        "https://www.bing.com",
        "http://httpbin.org/delay/3", // 模拟一个需要3秒响应的URL
        "https://www.nonexistent-domain-for-test.com", // 模拟一个无法访问的URL
    }

    // 定义每个请求的超时时间
    requestTimeout := 2 * time.Second

    // 创建一个带缓冲的通道，用于收集所有goroutine的抓取结果
    // 缓冲大小等于URL数量，可以避免发送方阻塞
    resultChan := make(chan FetchResult, len(urls))

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

    fmt.Printf("开始并行抓取 %d 个URL，每个请求超时 %s\n", len(urls), requestTimeout)

    for _, url := range urls {
        wg.Add(1) // 每次启动一个goroutine就增加计数器
        go func(currentURL string) {
            defer wg.Done() // goroutine结束时减少计数器

            // 为每个URL请求创建一个带有超时功能的上下文
            ctx, cancel := context.WithTimeout(context.Background(), requestTimeout)
            defer cancel() // 确保上下文被取消，释放资源

            fetchURLInGoroutine(ctx, currentURL, resultChan)
        }(url) // 将url作为参数传入匿名函数，避免闭包问题
    }

    // 启动一个goroutine来等待所有工作goroutine完成，然后关闭结果通道
    go func() {
        wg.Wait()      // 等待所有wg.Done()被调用
        close(resultChan) // 关闭通道，表示没有更多结果会发送
    }()

    // 从结果通道中读取所有结果
    for result := range resultChan {
        if result.Error != nil {
            fmt.Printf("URL: %s, 错误: %v\n", result.URL, result.Error)
        } else {
            // 为了简洁，只打印前100个字符
            contentPreview := result.Content
            if len(contentPreview) > 100 {
                contentPreview = contentPreview[:100] + "..."
            }
            fmt.Printf("URL: %s, 内容预览: %s\n", result.URL, contentPreview)
        }
    }

    fmt.Println("所有URL抓取任务完成。")
}