🤔🤔Go 并发越开越多,线上却越来越不稳?

1 阅读20分钟

一个接口原本需要 600ms,产品要求同时返回日志、指标和告警。

开发人员很自然地想到:既然三个下游互不依赖,为什么不直接开三个 goroutine 并行请求?

改完之后,接口耗时确实下降了。

但上线没多久,新的问题接踵而至:

  • 数据偶发缺失:三个下游还没执行完,接口已经返回。
  • goroutine 越堆越多:下游响应变慢,请求却不断创建新的并发任务。
  • 取消失效:客户端早已超时离开,服务端还在继续请求下游。
  • 依赖服务被打爆:本来只是想优化接口性能,结果并发请求反而放大了下游压力。

最开始只是想让接口快一点,最后却要花更多时间处理超时、资源泄漏和线上故障。

问题出在哪里?

Go 并发真正危险的地方,不是 goroutine 开得多,而是并发任务缺少明确的生命周期、错误处理、panic 边界和资源上限。

这篇文章从一个常见的聚合接口出发,解决三个问题:

  1. 为什么 go func() 加 sleep 是危险的?
  2. 如何用 context + errgroup 管理并发任务,并处理 panic 与错误聚合?
  3. 如何同时控制请求级、服务级和入口级并发,防止 goroutine 堆积和下游被打爆?

并发改造最容易踩的 4 个坑

先看一个典型场景。

一个 Overview 接口需要同时查询三个下游:

                  Overview API
                       |
             +---------+---------+
             |         |         |
           日志服务   指标服务   告警服务
             |         |         |
           Log      Metrics    Alerts
             +---------+---------+
                       |
                    合并结果
                       |
                    返回响应

是的,没错。三个请求没有依赖关系,完全可以并行执行。

理想情况下,接口耗时由三个下游中最慢的一个决定,而不是三个请求耗时之和。

但如果只考虑并行,不考虑任务管理,就很容易出现下面的问题。

坑一:用 sleep 等待 goroutine,结果完整性没有保障

先看一段错误示例:

func LoadOverview(svc string) (Overview, error) {
    var (
        logs    LogSummary
        metrics MetricSummary
        alerts  AlertSummary
    )

    go func() {
        logs = queryLogs(svc)
    }()

    go func() {
        metrics = queryMetrics(svc)
    }()

    go func() {
        alerts = queryAlerts(svc)
    }()

    // 错误做法:固定等待 300ms,无法保证三个任务都已完成
    time.Sleep(300 * time.Millisecond)

    // 可能返回尚未写入的数据,同时存在并发读写风险
    return Overview{
        Logs:    logs,
        Metrics: metrics,
        Alerts:  alerts,
    }, nil
}

这段代码存在三个问题:

  • 没有同步机制:sleep 300ms 不代表三个 goroutine 都执行完成。
  • 没有错误传播:下游失败后,接口依然可能返回成功。
  • 存在数据竞争:主 goroutine 和子 goroutine 并发读写共享变量。

记住:sleep 只能等待时间,不能等待任务完成。

坑二:只加锁和 channel,虽解决了同步,却没有解决生命周期

有人可能会继续打补丁:

var (
    mu      sync.Mutex
    logs    LogSummary
    metrics MetricSummary
    alerts  AlertSummary
)

done := make(chan struct{}, 3)  // 创建一个带缓冲的 channel,容量 3

go func() {
    v := queryLogs(svc)   // 1. 查日志
    mu.Lock()             // 2. 加锁
    logs = v              // 3. 写共享变量
    mu.Unlock()           // 4. 解锁
    done <- struct{}{}    // 5. 通知主 goroutine:我完成了
}()

// 主 goroutine 循环三次,每次从 `done` 接收一个信号。
// 第一次 `<-done` 阻塞到某个 goroutine 发信号,第二次阻塞到第二个,第三次阻塞到第三个。
// 三次收完,说明三个 goroutine 都执行过 `done <- struct{}{}` 了。
for i := 0; i < 3; i++ {
    <-done
}

// metrics、alerts 同样处理

相比第一版,这次至少有了明确的等待机制。但问题依然存在:

  • 下游请求失败怎么办?
  • 客户端取消后,任务是否停止?
  • 某个下游一直不返回怎么办?
  • 同一时间允许多少个请求访问下游?

锁和 channel 解决的是同步问题,不是并发任务的完整管理问题。

坑三:只限制单次请求,仍然可能打爆下游

假设每个请求最多并发访问三个下游。

单看一个请求,似乎完全没问题。但如果同时有 1000 个请求:

1000 个 API 请求
       |
       | 每个请求并发 3 个任务
       |
       v
最多 3000 个下游并发请求

这就是一个容易忽略的问题:请求级并发限制,不等于服务级并发限制。

即使使用 errgroup.SetLimit(3),也只能限制当前这一次请求内的并发任务数量。而且当任务总数刚好等于 limit 时,SetLimit(3) 不会起到限流排队效果;它的价值是应对动态提交更多任务的场景,提前约束并发上限。

如果没有全局并发控制、连接池限制或下游限流,高峰期依然可能把依赖服务打爆。

坑四:只限下游并发,没有入口限流,goroutine 照样越堆越多

这是一个更隐蔽的问题。

服务级信号量确实能把“同时访问下游的请求”限制住,但它不限制“等待获取信号量的 goroutine 数量”。

高 QPS 加上下游变慢时,每个请求仍然会创建 3 个 goroutine,大量 goroutine 阻塞在 Acquire 上,HTTP handler goroutine 也在等。结果只是把下游压力转成了自身的 goroutine、内存和排队压力。

10000 个入口请求
       |
       | 每个请求创建 3 个 goroutine
       |
       v
30000 个 goroutine,其中绝大多数阻塞在信号量上

所以并发控制必须分成多个层次,入口层要能快速拒绝或排队,而不是无限创建 goroutine。

那么,怎么正确并发呢?

1-48.jpeg

🔥🔥 正确的并发模型:context + errgroup + 边界保护

既然问题已经明确,就不要继续在原来的代码上堆补丁。

更合理的方式是重新定义并发任务的管理边界。这里使用两个核心工具:

工具解决的问题
context超时控制、请求取消、任务生命周期
errgroup并发任务管理、等待完成、错误传播

它们分别负责不同的事情,组合起来才能形成完整的请求级并发模型。在此基础上,还要补上 panic 边界、错误聚合和部分成功策略。

1. 建立统一的 context 生命周期

// 在原请求 context 的基础上增加 800ms 超时限制
ctx, cancel := context.WithTimeout(ctx, 800*time.Millisecond)
defer cancel()

两个关键点:

  • context.WithTimeout:限制整个聚合接口的执行时间。
  • defer cancel():确保函数退出后及时释放相关资源。

context 只负责传递取消信号,不会强制终止 goroutine。 下游 Client 必须主动监听并响应这个信号。

2. 使用 errgroup 管理并发任务,并加 panic 边界

先定义聚合数据结构和 Client 接口:

type Overview struct {
    Logs    LogSummary
    Metrics MetricSummary
    Alerts  AlertSummary

    // 标记是否有下游失败,便于调用方判断数据完整度
    Partial bool
    // 记录失败的下游名称,便于观测和排障
    // 用 []error 而不是 []string,保留原始错误类型,调用方仍可用 errors.Is 判断。
    // Load 永远返回 Partial=false、Failed=nil,这两个字段只供 LoadPartial 使用。
    Failed  []error
}

type LogClient interface {
    QuerySummary(ctx context.Context, svc string) (LogSummary, error)
}

type MetricClient interface {
    QuerySummary(ctx context.Context, svc string) (MetricSummary, error)
}

type AlertClient interface {
    QuerySummary(ctx context.Context, svc string) (AlertSummary, error)
}

type Loader struct {
    Logs    LogClient
    Metrics MetricClient
    Alerts  AlertClient
}

errgroup 不会自动 recover。某个 Client 里如果 panic,整个进程可能直接挂掉。所以需要一个带 panic 边界的辅助函数:

// 给 errgroup 任务加 panic 保护的包装函数
// safeGo 接收两个东西:一个 *errgroup.Group,和一个“业务函数” f。
// 它不直接执行 f,而是用一层匿名函数把 f 包起来,再交给 g.Go。
func safeGo(g *errgroup.Group, name string, f func() error) {
    // 关键在匿名函数签名:func() (err error)。它用了具名返回值err,这是整个技巧的核心
    // 如果没有这层包装,f() panic 会直接冲出 goroutine,Go runtime 打印堆栈并终止整个进程。
    // errgroup 的 Wait() 只负责等 goroutine 结束和收集返回值,它不 recover panic。
    g.Go(func() (err error) { 
        defer func() {
            if r := recover(); r != nil {
                err = fmt.Errorf("%s: panic: %v\n%s", name, r, debug.Stack())
            }
        }()
        return f()
    })
}

提示:示例中将完整堆栈放进 error 便于文章调试;线上业务不建议把完整堆栈打包进 error 返回,堆栈单独打印日志即可,避免 error 信息膨胀。

并发聚合逻辑:

func (l *Loader) Load(ctx context.Context, svc string) (Overview, error) {
    // 统一超时与取消。客户端主动取消、或者 800ms 到期,`ctx` 都会进入取消状态。`defer cancel()` 保证函数退出时释放 timer 资源。
    ctx, cancel := context.WithTimeout(ctx, 800*time.Millisecond)
    defer cancel()

    // 创建 errgroup 并限制并发。
    // `errgroup.WithContext` 返回的 `ctx` 会在第一个任务返回非 nil 错误时被取消,也会在 `Wait()` 返回后被取消。
    g, ctx := errgroup.WithContext(ctx)
    g.SetLimit(3) // 限制这个 group 最多同时跑 3 个任务。

    // 三个变量分别只被一个 goroutine 写,主 goroutine 在 `g.Wait()` 返回后读。
    // 这里没有数据竞争,因为 `Wait()` 返回建立了 happens-before:所有子 goroutine 的写都发生在主 goroutine 读之前。所以这三个变量不需要加锁。
    var (
        logs    LogSummary
        metrics MetricSummary
        alerts  AlertSummary
    )

    // 错误收集。线程安全地收集所有下游错误,而不是只保留第一个
    var (
        errMu sync.Mutex
        errs  []error
    )
    addErr := func(name string, err error) {
        errMu.Lock()
        // 因为三个 goroutine 都可能往 `errs` 里 append,所以必须用 mutex 保护。这是这段代码里唯一需要锁的地方。
        errs = append(errs, fmt.Errorf("%s: %w", name, err))
        errMu.Unlock()
    }

    // 以下是三个任务。
    // 三个任务结构相同。成功写独立变量,失败记录并返回错误。`safeGo` 负责把 panic 转成 error。
    safeGo(g, "logs", func() error {
        v, err := l.Logs.QuerySummary(ctx, svc)
        if err != nil {
            addErr("logs", err)
            return err
        }
        logs = v
        return nil
    })

    safeGo(g, "metrics", func() error {
        v, err := l.Metrics.QuerySummary(ctx, svc)
        if err != nil {
            addErr("metrics", err)
            return err
        }
        metrics = v
        return nil
    })

    safeGo(g, "alerts", func() error {
        v, err := l.Alerts.QuerySummary(ctx, svc)
        if err != nil {
            addErr("alerts", err)
            return err
        }
        alerts = v
        return nil
    })

    // 等待并合并错误
    waitErr := g.Wait()

    // 合并所有错误,保留完整排障信息
    errMu.Lock()
    allErrs := errors.Join(errs...)
    errMu.Unlock()

    if waitErr != nil {
        // 根据业务决定:全有或全无,还是部分成功
        if allErrs != nil {
            return Overview{}, errors.Join(waitErr, allErrs)
        }
        return Overview{}, waitErr
    }

    return Overview{
        Logs:    logs,
        Metrics: metrics,
        Alerts:  alerts,
    }, nil
}

这里有几个关键点:

  • 任务完成有明确的同步点。 g.Wait() 会等待所有任务结束。
  • 错误能够统一传播,而且不会只保留第一个。 errors.Join 保留所有下游错误。
  • 任务能够响应请求取消。 客户端取消或者整体超时后,三个下游都能收到取消信号。
  • panic 不会打挂进程。 safeGo 把 panic 转成错误。
  • 并发数量有明确上限。 SetLimit(3) 在这里主要是防止未来任务数增加,对固定三个任务本身不产生额外限制。

还有一个容易忽略的细节:errgroup.WithContext 创建的 context 会在任务返回错误时取消,而且 Wait() 返回后也会取消。因此,不要在 Wait() 之后继续使用这个 context 执行其他业务。

3. 部分成功策略要显式设计

上面的 Load 采用“全有或全无”策略。但聚合接口经常需要部分成功:一个下游不可用,不应该让整个接口不可用。用户能看到日志和指标,即使告警查询失败了,也比什么都看不到要好。

但这里有一个必须提前说清楚的实现约束:

LoadPartial 不能复用 Load 的 errgroup.WithContext。 errgroup 会在第一个任务返回错误时取消共享 context,其他下游会被提前打断,LoadPartial 就变成了“名义上部分成功,实际上还是快速失败”。正确的做法是用 sync.WaitGroup 启动任务,让每个下游独立执行完毕,最后统一收集结果和错误。

// Overview 已在第 2 节定义,这里不再重复定义。

func (l *Loader) LoadPartial(ctx context.Context, svc string) (Overview, error) {
    ctx, cancel := context.WithTimeout(ctx, 800*time.Millisecond)
    defer cancel()

    // 关键区别:不使用 errgroup.WithContext。
    // 单个下游失败不能取消其他下游,否则就不是“部分成功”。
    var wg sync.WaitGroup

    var (
        logs    LogSummary
        metrics MetricSummary
        alerts  AlertSummary
    )

    // 收集所有下游错误,而不是只保留第一个
    var (
        errMu sync.Mutex
        errs  []error
    )
    addErr := func(err error) {
        errMu.Lock()
        errs = append(errs, err)
        errMu.Unlock()
    }

    // run 负责启动任务、recover panic、统一加上下游名字后收集错误。
    // f 只返回原始错误,不再自己包装,避免错误信息重复。
    run := func(name string, f func() error) {
        wg.Add(1)
        go func() {
            defer wg.Done()
            defer func() {
                if r := recover(); r != nil {
                    addErr(fmt.Errorf("%s: panic: %v\n%s", name, r, debug.Stack()))
                }
            }()
            if err := f(); err != nil {
                addErr(fmt.Errorf("%s: %w", name, err))
            }
        }()
    }

    run("logs", func() error {
        v, err := l.Logs.QuerySummary(ctx, svc)
        if err != nil {
            return err
        }
        logs = v
        return nil
    })

    run("metrics", func() error {
        v, err := l.Metrics.QuerySummary(ctx, svc)
        if err != nil {
            return err
        }
        metrics = v
        return nil
    })

    run("alerts", func() error {
        v, err := l.Alerts.QuerySummary(ctx, svc)
        if err != nil {
            return err
        }
        alerts = v
        return nil
    })

    wg.Wait()

    // 重要边界:如果是客户端取消或整体超时,不属于“下游部分失败”,
    // 应该直接返回 ctx 错误,而不是伪装成部分成功。
    if err := ctx.Err(); err != nil {
        return Overview{}, err
    }

    // wg.Wait() 已建立 happens-before,这里读结果不需要再加锁。
    ov := Overview{
        Logs:    logs,
        Metrics: metrics,
        Alerts:  alerts,
    }

    errMu.Lock()
    ov.Failed = append(ov.Failed, errs...)
    errMu.Unlock()

    ov.Partial = len(ov.Failed) > 0

    if ov.Partial {
        // 部分成功是最需要度量的场景,不要只打一行日志。
        // 建议同时上报结构化指标,例如:
        // overview_partial_total{failed_downstream="logs"}
        for _, e := range ov.Failed {
            log.Warnf("partial overview: %v", e)
        }
    }

    return ov, nil
}

注意:sync.WaitGroup 会一直等待所有任务执行完毕,不会因为 ctx 超时自动终止等待。如果业务要求超时后立刻放弃等待,需要在循环里监听 ctx.Done()。

这段实现有几个关键点:

  • 独立执行,不互相取消。 用 WaitGroup 而不是 errgroup.WithContext,一个下游失败不会打断另外两个。
  • 错误保留类型。 Failed 是 []error,调用方可以用 errors.Is(err, context.DeadlineExceeded) 区分“下游超时”和“下游业务失败”。如果返回给前端,再在序列化层转成字符串或错误码。
  • 整体取消不等于部分成功。 wg.Wait() 之后先检查 ctx.Err(),客户端取消或 800ms 整体超时直接返回错误,避免把“请求被取消”误报成“部分数据可用”。
  • panic 也有归属。 run 的 recover 会把下游名字写进错误,不会因为某个 Client panic 就丢掉是哪一段出的问题。

调用方必须明确一个契约:LoadPartial 返回 nil error 不等于数据完整,必须检查 ov.Partial。 如果担心调用方漏判,也可以约定 Partial == true 时返回一个可识别的哨兵错误,用 err != nil 强制调用方进入分支;两种方式没有绝对优劣,取决于团队更习惯哪种契约。

测试时要覆盖这几种情况:

场景预期
三个下游全部成功Partial == false,Failed 为空,err == nil
一个下游失败Partial == true,Failed 只含该下游错误,其他字段有正常数据
多个下游失败Failed 包含全部失败下游,且 errors.Is 能识别原始错误类型
客户端取消 / 整体超时返回 ctx.Err(),不能返回部分成功
某个下游 panic进程不崩,Failed 中有带下游名字的 panic 错误

这样,Load 负责“强一致、快速失败”,LoadPartial 负责“尽力而为、显式标记完整度”,两种策略边界清晰,调用方可以根据业务语义选择。

4. 下游超时与重试预算

整体 800ms 超时不够细。生产上还应该考虑:

  • 每个下游单独超时:慢下游不应该拖垮整个聚合接口。
  • 重试预算:重试会放大下游流量,必须限制次数和总时间。
  • 剩余 deadline 传递:下游应该知道客户端还剩多少时间。
// 为单个下游设置更紧的超时,自动取父ctx剩余时间和配置超时的较小值
logDeadline, hasDeadline := ctx.Deadline()
logTimeout := 300 * time.Millisecond
if hasDeadline {
    if remain := time.Until(logDeadline); remain < logTimeout {
        logTimeout = remain
    }
}
logCtx, logCancel := context.WithTimeout(ctx, logTimeout)
defer logCancel()

v, err := l.Logs.QuerySummary(logCtx, svc)

重试要谨慎。并发 + 重试 + 超时一起改,很容易把下游打得更惨。建议先完成并发模型改造,再单独调整重试策略。

5. Client 层必须真正支持 context

前面的 Loader 已经把 context 传下去了,但如果 Client 没有使用它,取消机制依然无法生效。

func (c *LogClient) QuerySummary(ctx context.Context, svc string) (LogSummary, error) {
    // NewRequestWithContext 将 ctx 和请求绑定,ctx取消/超时会终止这个http请求
    req, err := http.NewRequestWithContext(ctx, http.MethodGet, c.url(svc), nil)
    if err != nil {
        return LogSummary{}, err
    }

    // Do 执行请求,会监听 req 绑定的 ctx,收到取消信号时中断IO
    resp, err := c.httpClient.Do(req)
    if err != nil {
        return LogSummary{}, err
    }
    // 必须关闭body,防止http连接泄漏
    defer resp.Body.Close()

    if resp.StatusCode != http.StatusOK {
        return LogSummary{}, fmt.Errorf("logs service returned status: %d", resp.StatusCode)
    }

    // 解析响应体
    return parseLogSummary(resp.Body)
}

最重要的是 http.NewRequestWithContext(ctx, ...)。它让 HTTP 请求与当前 context 关联。

并发任务能否真正退出,最终取决于最底层的 I/O 操作是否支持取消。

d522cab57c4deb76f9c290abe51e94890319fe0d.jpeg

🤔🤔请求级之外,还需要服务级、入口级和连接池控制

使用信号量限制全局下游并发(修正竞态)

很多伙伴只在单次请求内用 errgroup 做并发控制,忽略了跨请求共享的下游并发上限。errgroup 的限制只对当前这一次请求生效,多个请求同时进来时,下游总并发会叠加打爆依赖。

进程内信号量是用来约束整个服务实例访问同一个下游的全局并发,属于服务侧资源保护。

// Semaphore 进程内信号量,用于控制单实例访问下游服务的最大并发数
type Semaphore struct {
	slots chan struct{}
}

// NewSemaphore 创建信号量,limit为最大并发槽位
func NewSemaphore(limit int) (*Semaphore, error) {
	if limit <= 0 {
		return nil, fmt.Errorf("semaphore limit must be positive")
	}
	return &Semaphore{slots: make(chan struct{}, limit)}, nil
}

// Acquire 获取信号量槽位,支持context超时/取消
// select是原子操作:要么成功拿到槽位,要么ctx先取消,不存在拿到槽后再回吐的竞态风险
func (s *Semaphore) Acquire(ctx context.Context) error {
	// 快速短路:ctx已经取消,直接返回,无需进入select
	if err := ctx.Err(); err != nil {
		return err
	}
	select {
	case s.slots <- struct{}{}:
		// 成功获取槽位
		return nil
	case <-ctx.Done():
		// 请求提前取消/超时,获取失败
		return ctx.Err()
	}
}

// Release 释放槽位,必须和Acquire成对使用,建议搭配defer
func (s *Semaphore) Release() {
	<-s.slots
}

使用方式:

// 尝试获取下游并发名额
if err := semaphore.Acquire(ctx); err != nil {
	return LogSummary{}, err
}
// 函数退出时释放槽位
defer semaphore.Release()

return client.QuerySummary(ctx, svc)

信号量应该由服务实例共享,不能每个请求重新创建。如果如上说的三个下游承载能力不同,最好分别设置并发限制。

多实例部署时,进程内信号量不是集群级限制,需要结合网关、下游限流或分布式资源控制。

入口 in-flight 限制:防止 goroutine 堆积

in-flight 指已经进入服务、还没有处理完成的请求。信号量只限制下游并发,不限制等待中的 goroutine。入口层还需要快速拒绝或排队:

// InFlightLimiter 单实例并发请求控制器,限制当前实例同时处理的请求总数
type InFlightLimiter struct {
	sem chan struct{}
}

// NewInFlightLimiter 创建入口并发限制器
func NewInFlightLimiter(limit int) *InFlightLimiter {
	return &InFlightLimiter{sem: make(chan struct{}, limit)}
}

// TryAcquire 非阻塞尝试获取名额,获取失败直接返回false,快速失败
func (l *InFlightLimiter) TryAcquire() bool {
	select {
	case l.sem <- struct{}{}:
		return true
	default:
		return false
	}
}

// Release 释放名额,defer保证释放
func (l *InFlightLimiter) Release() {
	<-l.sem
}

原生 net/http handler 使用示例:

// 尝试获取入口处理名额
if !limiter.TryAcquire() {
	http.Error(w, "too many requests", http.StatusTooManyRequests)
	return
}
defer limiter.Release()

以 Gin 框架来说,handler 写法调整如下:

// Gin handler 内使用in-flight限制器
if !limiter.TryAcquire() {
	// 返回标准429限流响应
	c.JSON(http.StatusTooManyRequests, gin.H{"code": 429, "msg": "too many requests"})
	return
}
defer limiter.Release()

这样高峰期会快速失败,而不是无限创建 goroutine。配合监控 in-flight 数量、拒绝率和信号量等待时间,才能及时发现容量问题。

连接池和 Transport 限制

连接池和 Transport 指 Go http.Client 底层的 TCP 连接复用管理器,控制与下游建立、复用、回收 TCP 连接,是容易被忽略的底层瓶颈。

只靠信号量还不够。HTTP Client 还需要关注底层连接池配置,避免连接耗尽:

transport := &http.Transport{
	MaxConnsPerHost:     50,  // 单个host最大并发连接数
	MaxIdleConnsPerHost: 20,  // 单个host最大空闲连接数
	IdleConnTimeout:     90 * time.Second, // 空闲连接超时,自动回收
}

同时还要配置 http.Server 的读写超时、请求体大小限制。否则并发控制逻辑和连接池行为不一致,依然会出现连接泄漏、连接打满问题。

并发控制分成四个层次

控制层主要作用常见方案
入口级限制单实例同时处理的请求数,快速拒绝InFlightLimiter
请求级限制单次请求的任务数量errgroup.SetLimit
服务级限制单实例下游总并发Semaphore
集群级管控多个实例的整体流量与下游总配额APISIX/Gateway 网关限流、下游配额

补充说明:集群级限流(APISIX、Ingress Gateway)一般在网关控制台配置规则即可,不需要编写业务代码;它负责拦截外部大流量洪峰,而进程内 InFlightLimiter 作为服务侧兜底防护,用来解决下游 RT 恶化引发的服务内部 goroutine 堆积问题,二者搭配使用。

还有一点值得注意:并发限制不等于 QPS 限制。并发限制管控同一时间正在执行的任务数量;QPS 限制管控单位时间内发起的请求总量。如果下游有严格的请求频率配额,还需要额外引入令牌桶这类限速机制。

补充:文中实现的信号量属于进程内单机信号量,只对当前单个 Pod 生效。在多 Pod、多集群部署场景,各个 Pod 独立计数,无法感知其他实例的并发,因此不能实现全局并发上限。 工程上的取舍建议:

  • 首选方案:让下游服务自身做好限流、熔断、配额,这是最稳定、运维成本最低的方式;
  • 备选方案:如果业务硬性要求我方侧统一管控所有实例对下游的总并发,再引入基于 Redis 的分布式令牌桶 / 分布式信号量,但会带来额外的网络开销、竞态、可用性问题,复杂度明显更高,非必要不使用。

这里有一个常见误区:横向扩容 Pod 和接口内部 fan-out 并发并不冲突。

扩容是为了承载更高的入口 QPS,而单个请求内部并行调用下游,是为了降低接口响应耗时;但随着 Pod 数量增加,每个 Pod 内部的并发会叠加,下游收到的总并发压力会同步放大,这也是优先依赖下游防护的核心原因。

4bed2e738bd4b31cfc6dad318efea5749f2ff89e.webp

最后总结:Go 并发必须守住这 4 条边界

回到最初的问题。

三个下游并行调用,确实能够缩短接口响应时间。

但并发改造真正需要交付的,不只是更快的执行速度,而是可控的任务生命周期、明确的错误传播、panic 边界和稳定的资源边界。

可以记住这四条:

  1. 同步边界: 不要用 sleep 等待任务完成,使用 errgroup 或 WaitGroup 建立明确的同步点。
  2. 生命周期边界: 从 Handler 到 Client 传递 context,让取消和超时能够贯穿整个调用链。
  3. 故障边界: goroutine 入口加 recover,错误要聚合而不是只保留第一个,部分成功策略要显式设计。
  4. 资源边界: 入口 in-flight 做快速拒绝,请求级依靠 errgroup.SetLimit,服务级使用信号量,配套连接池、网关集群限流一起防护。

Go 并发最容易犯的错误,就是只看到 goroutine 带来的性能提升,却忽略了它同时带来的资源消耗和生命周期管理问题。

希望这篇文章对你有所帮助,有所借鉴。