Go语言中嵌套goroutine的退出控制与API请求并发效率咨询

我来帮你逐一拆解这些问题，结合你的任务组+API请求场景给出具体的解决方案和思路：

一、嵌套Goroutine的退出控制 #

1. 一级Goroutine如何终止二级Goroutine #

你需要用**上下文（Context）**来统一管理一组Goroutine的生命周期，比单独传stopChan更灵活适配多子Goroutine场景。比如每个任务组（一级Goroutine）启动时，创建一个带取消功能的Context：

// 启动一个任务组（一级Goroutine）
ctx, cancel := context.WithCancel(context.Background())
go func() {
    defer cancel() // 任务组自身正常退出时，也主动触发取消避免资源泄漏
    var wg sync.WaitGroup
    // 给每个API请求的二级Goroutine传递这个ctx
    for i := 0; i < 300; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            runAPIRequest(ctx)
        }()
    }
    wg.Wait() // 等待所有二级Goroutine完成
}()

// 当用户需要终止该任务组时，调用cancel()即可
cancel()

调用cancel()后，所有基于这个ctx的二级Goroutine都会收到取消信号，只要在代码中监听ctx.Done()就能及时退出。

2. 非循环场景下响应退出信号 #

如果runGoroutine不需要循环，你可以在业务逻辑的关键节点检查取消信号，不用死循环也能响应退出：

func runAPIRequest(ctx context.Context) {
    // 先检查是否已取消，避免做无用功
    select {
    case <-ctx.Done():
        fmt.Println("请求已取消，退出")
        return
    default:
    }

    // 把ctx传给HTTP请求，底层会自动响应取消（比如请求还在等待时收到取消，会中断请求）
    req, err := http.NewRequestWithContext(ctx, "GET", "https://api.example.com", nil)
    if err != nil {
        // 错误处理
        return
    }

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        // 区分取消导致的错误，直接退出
        if errors.Is(err, context.Canceled) {
            return
        }
        // 其他错误处理
        return
    }
    defer resp.Body.Close()

    // 后续响应处理逻辑...
}

这样即使没有循环，只要在业务开始前、耗时操作前检查ctx.Done()，就能及时响应退出信号。

3. 异步子Goroutine不会随父Goroutine返回自动退出 #

划重点：父Goroutine执行完毕返回后，它启动的子Goroutine会继续独立运行，直到自己执行完毕或被外部信号终止。所以你必须主动给每个子Goroutine传递取消信号（比如Context），否则这些子Goroutine会变成“孤儿Goroutine”，可能导致资源泄漏。

二、API请求的并发效率与资源选择 #

并发Goroutine vs 单线程：速度差异巨大 #

针对你的场景（200-300个API请求），每个请求用单独Goroutine的速度会远快于单线程串行执行，核心原因是：

• API请求属于网络IO密集型任务，大部分时间都在等待远程服务器的响应，而非占用CPU计算。
• 单线程串行执行时，必须等前一个请求完全响应后才能发起下一个，总耗时是所有请求响应时间的总和。
• 用Goroutine并发执行时，能同时发起多个请求，总耗时接近最慢的单个请求的响应时间（忽略Goroutine调度的微小开销），这对速度的提升是数量级的。

控制并发数：避免过载 #

虽然Goroutine很轻量（初始栈仅几KB，动态扩容），但也不能无限制创建（比如一次性发起1000个请求可能触发API限流、本地端口耗尽）。你可以用Worker Pool模式（就像你最后给出的新代码那样），控制同时运行的Goroutine数量，比如设置50-100个Worker，既保证并发效率，又避免资源过载。

你的架构与参考代码 #

架构示意图 #

Parent/Main process
                        |              |
          Child goroutine            Child goroutine
                |                           |
      X bottom goroutines          X bottom goroutines           (API level)

优化后的参考代码（贴合你的场景） #

这段代码用context.WithCancel管理任务组生命周期，Worker Pool控制API请求并发数，同时支持用户主动终止任务：

package main

import (
    "context"
    "errors"
    "fmt"
    "log"
    "net/http"
    "sync"
    "time"
)

func main() {
    // 初始化带取消功能的上下文
    ctx, cancel := context.WithCancel(context.Background())
    defer cancel() // 确保main退出时，所有任务都能被取消

    // 启动一个任务组（一级Goroutine）：20个Worker，处理300个API请求
    go startWorkerPool(ctx, 20, 300)
    
    // 模拟用户CLI交互：输入9时终止所有任务
    log.Println("任务组已启动，输入数字9可终止所有任务")
    waitForNine(cancel)
}

func waitForNine(cancel context.CancelFunc) {
    var input int
    for input != 9 {
        fmt.Print("请输入数字：")
        if _, err := fmt.Scan(&input); err != nil {
            log.Println("输入无效，请重新输入")
            continue
        }
    }
    log.Println("正在终止所有任务...")
    cancel() // 触发任务组取消
    time.Sleep(1 * time.Second) // 等待所有Goroutine完成退出（实际项目可用WaitGroup替代）
    log.Println("所有任务已终止")
}

// startWorkerPool 启动固定大小的Worker池，处理指定数量的API请求
func startWorkerPool(ctx context.Context, numWorkers, numRequests int) {
    var wg sync.WaitGroup
    workChan := make(chan string, numRequests) // 带缓冲的任务通道

    // 启动Worker
    for i := 0; i < numWorkers; i++ {
        wg.Add(1)
        go func(workerID int) {
            defer wg.Done()
            client := &http.Client{Timeout: 10 * time.Second}
            for url := range workChan {
                select {
                case <-ctx.Done():
                    log.Printf("Worker %d：收到终止信号，退出", workerID)
                    return
                default:
                    if err := performAPIRequest(ctx, client, url); err != nil {
                        log.Printf("Worker %d：请求失败：%v", workerID, err)
                    } else {
                        log.Printf("Worker %d：请求成功", workerID)
                    }
                }
            }
        }(i)
    }

    // 填充任务到通道
    go func() {
        defer close(workChan)
        for i := 0; i < numRequests; i++ {
            select {
            case <-ctx.Done():
                return // 提前取消时，停止添加任务
            case workChan <- "https://httpbin.org/get":
            }
        }
    }()

    wg.Wait()
    log.Println("所有API请求已处理完成或终止")
}

// performAPIRequest 执行单个API请求，支持上下文取消
func performAPIRequest(ctx context.Context, client *http.Client, url string) error {
    req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
    if err != nil {
        return fmt.Errorf("创建请求失败：%w", err)
    }

    resp, err := client.Do(req)
    if err != nil {
        if errors.Is(err, context.Canceled) {
            return fmt.Errorf("请求已取消：%w", err)
        }
        return fmt.Errorf("发送请求失败：%w", err)
    }
    defer resp.Body.Close()

    // 这里可添加响应内容处理逻辑
    return nil
}

备注：内容来源于stack exchange，提问作者Ahmed Zaidan