使用 channel 收集 并发 http 请求结果，通过 Result结构体 封装 响应数据，每个goroutine 将结果发送到统一 channel，主协程从 channel 接收并处理所有结果。
在 Go 语言 中处理并发 HTTP 请求结果，关键在于合理使用goroutine、channel 和 context 来协调多个请求的执行与结果收集。下面介绍几种常见且实用的方法。
使用 Channel 收集结果
启动多个 goroutine 并发发送 HTTP 请求，每个请求的结果通过 channel 传回主协程。这种方式能有效避免竞态条件，并保证数据安全。
定义一个结构体来封装响应数据或错误：
type Result struct {URL string Body []byte Error error }然后为每个请求启动一个 goroutine，将结果发送到统一的 channel：
立即学习“go 语言免费学习笔记（深入）”；
results := make(chan Result, len(urls)) for _, url := range urls {go func(u string) {resp, err := http.Get(u) if err != nil {results <- Result{URL: u, Error: err} return } defer resp.Body.Close() body, _ := io.ReadAll(resp.Body) results <- Result{URL: u, Body: body} }(url) }从 channel 读取所有结果：
var finalResults []Result for range urls { result := <-results finalResults = append(finalResults, result) }使用 WaitGroup 控制协程生命周期
当需要等待所有请求完成时，sync.WaitGroup 可以配合 channel 使用，确保所有 goroutine 都已退出。
var wg sync.WaitGroup results := make(chan Result, len(urls)) <p>for <em>, url := range urls {wg.Add(1) go func(u string) {defer wg.Done() // 发起请求并发送结果到 channel resp, err := http.Get(u) if err != nil {results <- Result{URL: u, Error: err} return } defer resp.Body.Close() body, </em> := io.ReadAll(resp.Body) results <- Result{URL: u, Body: body} }(url) }</p><p>go func() { wg.Wait() close(results) }()</p><p>var finalResults []Result for result := range results {finalResults = append(finalResults, result) }</p>使用 Context 控制超时和取消
并发请求中，应设置合理的超时时间，防止某个请求长时间阻塞整体流程。通过 context.WithTimeout 可实现全局超时控制。
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) defer cancel() <p>client := &http.Client{Timeout: 10 * time.Second} // 单个请求最大超时 </p><p>for <em>, url := range urls {req, </em> := http.NewRequestWithContext(ctx, "GET", url, nil) go func(u string) {resp, err := client.Do(req) if err != nil {results <- Result{URL: u, Error: err} return } defer resp.Body.Close() body, _ := io.ReadAll(resp.Body) results <- Result{URL: u, Body: body} }(url) }</p>这样即使某个请求慢，也不会影响整体流程在指定时间内完成。
限制并发数量（使用信号量）
如果请求量大，同时发起全部 HTTP 调用可能耗尽资源。可用带缓冲的 channel 模拟信号量，控制最大并发数。
semaphore := make(chan struct{}, 10) // 最多 10 个并发 <p>for _, url := range urls {semaphore <- struct{}{} // 获取令牌 go func(u string) {defer func() {<-semaphore}() // 释放令牌 </p><pre class='brush:php;toolbar:false;'> // 执行 HTTP 请求…… resp, err := http.Get(u) if err != nil {results <- Result{URL: u, Error: err} return } defer resp.Body.Close() body, _ := io.ReadAll(resp.Body) results <- Result{URL: u, Body: body} }(url)}
基本上就这些。结合 channel 传递结果、WaitGroup 同步生命周期、context 控制超时、以及信号量限制并发，就能写出稳定高效的并发 HTTP 请求处理逻辑。不复杂但容易忽略细节，比如关闭 response body 和正确管理 goroutine 退出。
