Go并发编程errgroup的使用方法和常见问题

你是否写过这样一个函数：它长得离谱，不是因为逻辑复杂，而是因为它要一口气干完好几件完全不相关的事情？比如，从数据库里拉用户信息，同时调个外部服务查最近活动，再顺手记一笔登录日志——可这些任务之间压根没有数据依赖。

这种场景很常见。一个函数里塞了3件事：

• 按用户ID从数据库获取用户详细信息
• 调用外部服务，按用户ID获取用户最近活动信息
• 访问日志服务，按用户ID获取用户上次登录的详细信息

func FetchUserData(userID string) error {
    g := errgroup.Group{}
    
	// 获取用户详细信息
    userDetail, _ := fetchUserDetails(userID)
	// 获取用户活动
    userAct, _ := fetchUserActivity(userID)
    // 获取用户登录详细信息
    userLoginInfo, _ := fetchUserLoginDetails(userID)

    // ...
}

所有任务都只依赖同一个userID，彼此之间没有数据交换——那为什么不并行跑呢？

直接用goroutine也能做，但需要自己处理一堆细节：怎么确保所有任务都完成？如果某个任务出错，是继续还是放弃？三个任务里有两个失败怎么办？一个任务挂掉，其他正在跑的goroutine怎么优雅地停下来？同时跑多少个才算合理？以及，这套方案能不能复用？

这些问题，正好是errgroup包要解决的。

1.什么是errgroup？

errgroup 包能让你以安全、一致的方式同时处理多项任务，并且自动完成同步、错误处理和生命周期控制。

下面是一个快速示例：

func FetchUserData() error {
	g := errgroup.Group{}

	// 获取用户详细信息
	g.Go(func() error {
		time.Sleep(1 * time.Second)
		fmt.Println("Fetched user details...")
		return nil
	})

    // 获取用户活动
    g.Go(func() error {
		time.Sleep(1 * time.Second)
		fmt.Println("Fetched user activity...")
		return nil
	})

	// 获取用户登录详细信息
	g.Go(func() error {
		time.Sleep(2 * time.Second)
		fmt.Println("Fetched user login details...")
		return nil
	})

	// 等待所有goroutines完成并返回第一个错误 (如果有)
	return g.Wait()
}

把任务塞进g.Go()，然后调用g.Wait()等待所有任务结束——就这么简单。当任务数量翻倍到10个、20个时，这种方式的优势就非常明显了。

不过，不加限制地同时跑太多goroutine会吃掉大量资源。怎么控制并发数？

2.SetLimit：限制程序运行次数

errgroup提供了SetLimit方法，用来限制同时运行的goroutine数量：

func FetchUserData() error {
    g := errgroup.Group{}

    // 将限制设置为2
    g.SetLimit(2)

    // 获取用户详细信息
    g.Go(func() error {
        time.Sleep(1 * time.Second)
        fmt.Println("Fetched user details...")
        return nil
    })

    // 获取用户活动
    g.Go(func() error {
        time.Sleep(1 * time.Second)
        fmt.Println("Fetched user activity...")
        return nil
    })

    // 获取用户登录详细信息
    g.Go(func() error {
        time.Sleep(2 * time.Second)
        fmt.Println("Fetched user login details...")
        return nil
    })

    // 等待所有goroutines完成并返回第一个错误 (如果有)
    return g.Wait()
}

设置SetLimit(2)后，最多只有两个goroutine同时运行。你可以试试看：前两个任务会几乎同时打印信息，而第三个任务会等到前两个之一完成后才开始，整个过程大约需要3秒。

设置限值后还能再改吗？

可以，但要注意：如果已经有goroutine正在运行，再调用SetLimit会触发panic。所以最好在启动任务之前就把限制设好。

假设已经有50个goroutine在errgroup里跑着，但你不想再往里加新的了，怎么办？

3.TryGo：添加快速程序的受控方法

TryGo和Go类似，但行为更精细：如果当前goroutine数量已经达到上限，它会直接返回false，而不是阻塞等待。

// TryGo: 检查并添加 goroutine
func (g *Group) TryGo(fn func () error) bool

// Go: 只需添加一个 goroutine
func (g *Group) Go(fn func () error)

使用TryGo时，如果成功添加goroutine，返回true；如果已达上限，立即返回false，不会阻塞。而Go在组已满时会阻塞，直到有空位才添加新任务。这个区别在需要动态控制并发时非常有用。

4.WithContext：处理取消

如果其中一个任务出错，怎么让其他还在跑的任务立刻停下来，避免浪费资源？

WithContext函数可以创建一个带context的errgroup：

erg, ctx := errgroup.WithContext(context.Background())

这个函数返回一个context，但没有提供取消函数——你没法手动取消它。那错误发生时怎么办？

如果出现错误，errgroup会帮我停止所有程序吗？

不完全是。errgroup会取消这个context，但不会主动停止goroutine。其他goroutine会继续运行，直到它们自己检查context并退出。所以，让每个任务都依赖这个context才是关键：

func main() {
  g, ctx := errgroup.WithContext(context.Background())
  
  g.Go(func() error { return fetchUserDetails(ctx) })
  g.Go(func() error { return fetchUserActivity(ctx) })
  g.Go(func() error { return fetchUserPaymentHistory(ctx) })
  
  // Wait for tasks to finish and print the error
  if err := g.Wait(); err != nil {
    fmt.Printf("Encountered an error: %v\n", err)
  }
}

如果fetchUserDetails返回错误，context会被取消，其他任务在检查ctx.Done()后就能感知到并提前退出。这样既减少了额外代码，又优雅地控制了goroutine的生命周期。

5.总结

errgroup的核心价值在于：用简洁的API解决了并发场景下的同步、错误传递、取消和资源限制问题。它不追求花哨，但每个细节都经过精心设计——从Go到TryGo，从SetLimit到WithContext，都能在实际项目中派上用场。下次再遇到那种“一个函数干三件事”的场景，不妨试试它。