golang-- sync.WaitGroup 和 errgroup.Group 详解

原创 于 2025-12-19 14:34:14 发布 · 564 阅读 · 6 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
标签
#golang #开发语言 #后端

1. sync.WaitGroup

基本介绍

sync.WaitGroup 是 Go 标准库中用于等待一组 goroutine 完成执行的同步原语。

核心方法

type WaitGroup struct {
    // 内部字段
}

func (wg *WaitGroup) Add(delta int)  // 增加等待计数
func (wg *WaitGroup) Done()          // 完成一个任务（计数-1）
func (wg *WaitGroup) Wait()          // 阻塞直到计数为0

使用示例

package main

import (
    "fmt"
    "sync"
    "time"
)

func main() {
    var wg sync.WaitGroup
    
    for i := 1; i <= 3; i++ {
        wg.Add(1) // 为每个 goroutine 增加计数
        
        go func(id int) {
            defer wg.Done() // goroutine 结束时减少计数
            
            fmt.Printf("Worker %d starting\n", id)
            time.Sleep(time.Second)
            fmt.Printf("Worker %d done\n", id)
        }(i)
    }
    
    wg.Wait() // 等待所有 goroutine 完成
    fmt.Println("All workers completed")
}

重难点

  1. Add 必须在 goroutine 启动前调用

    // 正确
wg.Add(1)
go func() { defer wg.Done(); /* 工作 */ }()

// 错误
go func() {
    wg.Add(1)  // 可能在 Wait 之后执行，导致 Wait 过早返回
    defer wg.Done()
    /* 工作 */
}()

  2. Done 必须在所有路径上调用

    go func() {
    defer wg.Done()  // 使用 defer 确保在所有返回路径上都调用
    
    if err := doWork(); err != nil {
        return  // defer 仍会调用 wg.Done()
    }
    // 其他处理
}()

  3. WaitGroup 不能复制

    var wg1 sync.WaitGroup
wg1.Add(1)
// wg2 := wg1  // 错误！WaitGroup 不应复制

  4. 避免在 goroutine 中调用 Add

    // 反模式
for i := 0; i < 10; i++ {
    go func() {
        wg.Add(1)  // 竞态条件！
        defer wg.Done()
        // ...
    }()
}

2. errgroup.Group

基本介绍

errgroup.Group 来自 golang.org/x/sync/errgroup 包，在 WaitGroup 基础上增加了：

  • 错误传播机制
  • 上下文取消功能
  • 当有 goroutine 返回错误时，自动取消其他 goroutine

核心方法

/*
WithContext(ctx Context) (*Group, Context)：可传入自定义 context，实现更灵活的取消控制（如超时、外部信号取消）。
*/
func WithContext(ctx context.Context) (*Group, context.Context)
func (g *Group) Go(f func() error)//启动一个 goroutine 执行函数 f，若 f 返回错误，会记录第一个错误，并通过内置 context 发送取消信号；
func (g *Group) Wait() error//阻塞直到所有 goroutine 完成，返回第一个发生的错误（后续错误会被忽略）；
func (g *Group) SetLimit(n int)  // 限制并发数
func (g *Group) TryGo(f func() error) bool

使用示例

package main

import (
    "context"
    "fmt"
    "time"
    "errors"
    
    "golang.org/x/sync/errgroup"
)

func main() {
    g, ctx := errgroup.WithContext(context.Background())
    
    // 启动多个并发任务
    for i := 1; i <= 3; i++ {
        id := i
        g.Go(func() error {
            fmt.Printf("Worker %d starting\n", id)
            
            // 模拟工作，可能返回错误
            select {
            case <-time.After(time.Duration(id) * time.Second):
                if id == 2 {
                    return errors.New("worker 2 failed")
                }
                fmt.Printf("Worker %d done\n", id)
                return nil
            case <-ctx.Done():
                // 其他任务失败，收到取消信号
                fmt.Printf("Worker %d cancelled: %v\n", id, ctx.Err())
                return ctx.Err()
            }
        })
    }
    
    // 等待所有任务完成，返回第一个错误
    if err := g.Wait(); err != nil {
        fmt.Printf("One of the workers failed: %v\n", err)
    } else {
        fmt.Println("All workers completed successfully")
    }
}

重难点

  1. 错误传播机制

    g.Go(func() error {
    if err := doSomething(); err != nil {
        return fmt.Errorf("task failed: %w", err)  // 错误会被传播
    }
    return nil
})

  2. 上下文取消集成

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

g.Go(func() error {
    // 创建一个可取消的上下文
    subCtx, cancel := context.WithTimeout(ctx, 5*time.Second)
    defer cancel()
    
    return doTaskWithTimeout(subCtx)
})

  3. 并发数限制

    g, _ := errgroup.WithContext(context.Background())
g.SetLimit(3)  // 最多同时运行3个goroutine

for i := 0; i < 10; i++ {
    g.Go(func() error {
        // 最多3个同时执行
        return doWork()
    })
}

3. 使用场景对比

适用场景举例

sync.WaitGroup 适用场景

无错误场景的批量 goroutine 等待（如批量写入日志、无返回值的异步任务、纯消费型 goroutine）

  1. 简单的并行计算

    // 并行计算斐波那契数列
func parallelFibonacci(n int) int {
    var wg sync.WaitGroup
    ch := make(chan int, 2)
    
    wg.Add(2)
    go func() { defer wg.Done(); ch <- fib(n-1) }()
    go func() { defer wg.Done(); ch <- fib(n-2) }()
    
    wg.Wait()
    close(ch)
    
    return <-ch + <-ch
}

  2. 并发数据收集

    // 并发获取多个URL
func fetchURLs(urls []string) []string {
    var wg sync.WaitGroup
    results := make([]string, len(urls))
    
    for i, url := range urls {
        wg.Add(1)
        go func(idx int, u string) {
            defer wg.Done()
            resp, _ := http.Get(u)
            results[idx] = resp.Status
        }(i, url)
    }
    
    wg.Wait()
    return results
}

  3. 批处理任务

    // 批量处理文件
func processFiles(files []string) {
    var wg sync.WaitGroup
    
    for _, file := range files {
        wg.Add(1)
        go func(f string) {
            defer wg.Done()
            processFile(f)  // 忽略错误
        }(file)
    }
    
    wg.Wait()
}

errgroup.Group 适用场景

需要错误感知 + 快速失败的并发场景（如批量接口调用、多数据源查询、分布式任务调度，一个失败则终止所有）

  1. 需要错误处理的微服务调用,任一服务失败，整个操作失败

    func callServices(ctx context.Context) error {
    g, ctx := errgroup.WithContext(ctx)
    
    g.Go(func() error {
        return callUserService(ctx)
    })
    
    g.Go(func() error {
        return callOrderService(ctx)
    })
    
    g.Go(func() error {
        return callPaymentService(ctx)
    })
    
    return g.Wait() 
}

  2. 需要资源清理的初始化

    func initializeComponents() error {
    g, ctx := errgroup.WithContext(context.Background())
    
    // 并行初始化多个组件
    var db *sql.DB
    g.Go(func() error {
        var err error
        db, err = initDatabase(ctx)
        return err
    })
    
    var cache *redis.Client
    g.Go(func() error {
        var err error
        cache, err = initCache(ctx)
        return err
    })
    
    // 如果有初始化失败，确保清理
    if err := g.Wait(); err != nil {
        if db != nil { db.Close() }
        if cache != nil { cache.Close() }
        return err
    }
    
    return nil
}

  3. 有依赖关系的任务链

    func pipelineProcessing(data []string) error {
    g, ctx := errgroup.WithContext(context.Background())
    
    // 第一阶段：数据预处理
    stage1 := make(chan string, len(data))
    g.Go(func() error {
        defer close(stage1)
        for _, item := range data {
            processed, err := preprocess(ctx, item)
            if err != nil { return err }
            select {
            case stage1 <- processed:
            case <-ctx.Done():
                return ctx.Err()
            }
        }
        return nil
    })
    
    // 第二阶段：数据转换
    stage2 := make(chan Result, len(data))
    g.Go(func() error {
        defer close(stage2)
        for item := range stage1 {
            result, err := transform(ctx, item)
            if err != nil { return err }
            select {
            case stage2 <- result:
            case <-ctx.Done():
                return ctx.Err()
            }
        }
        return nil
    })
    
    return g.Wait()
}

4. 核心区别总结

特性sync.WaitGrouperrgroup.Group
错误处理无内置支持，需手动处理自动传播第一个错误，支持错误取消
上下文集成无支持 context 传播和取消
并发控制无支持 SetLimit 限制并发数
易用性较简单功能丰富，但稍复杂
内存使用较小稍大（维护额外状态）
标准库是需要额外导入
适用场景简单并行任务需要错误处理的复杂任务链

5. 高级使用技巧

组合使用模式

func complexOperation() error {
    var wg sync.WaitGroup
    errCh := make(chan error, 1)
    
    // 使用 WaitGroup 并行执行独立任务
    for i := 0; i < 5; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            if err := independentTask(id); err != nil {
                select {
                case errCh <- fmt.Errorf("task %d failed: %w", id, err):
                default:
                }
            }
        }(i)
    }
    
    // 使用 errgroup 处理有依赖的任务链
    g, ctx := errgroup.WithContext(context.Background())
    g.Go(func() error {
        return dependentTaskChain(ctx)
    })
    
    // 等待所有任务完成
    wg.Wait()
    close(errCh)
    
    // 检查独立任务的错误
    if err := <-errCh; err != nil {
        return err
    }
    
    // 检查依赖任务的错误
    return g.Wait()
}

带超时控制的 errgroup

func operationWithTimeout(timeout time.Duration) error {
    ctx, cancel := context.WithTimeout(context.Background(), timeout)
    defer cancel()
    
    g, ctx := errgroup.WithContext(ctx)
    
    for i := 0; i < 3; i++ {
        g.Go(func() error {
            return doTaskWithContext(ctx)
        })
    }
    
    return g.Wait()
}

6. 常见陷阱与解决方案

WaitGroup 陷阱

// 陷阱1：计数不匹配
func trap1() {
    var wg sync.WaitGroup
    wg.Add(1)
    go func() {
        // 忘记调用 wg.Done()
    }()
    wg.Wait()  // 永远阻塞
}

// 解决方案：始终使用 defer
func solution1() {
    var wg sync.WaitGroup
    wg.Add(1)
    go func() {
        defer wg.Done()  // 确保调用
        // 任务逻辑
    }()
    wg.Wait()
}

errgroup 陷阱

// 陷阱：错误处理中的资源泄漏
func trap2() error {
    g, ctx := errgroup.WithContext(context.Background())
    
    g.Go(func() error {
        conn, err := acquireConnection()
        if err != nil { return err }
        // 如果后续有错误，conn 可能泄漏
        return doWork(ctx, conn)
    })
    
    return g.Wait()
}

// 解决方案：使用 defer 清理
func solution2() error {
    g, ctx := errgroup.WithContext(context.Background())
    
    g.Go(func() error {
        conn, err := acquireConnection()
        if err != nil { return err }
        defer conn.Close()  // 确保清理
        
        return doWork(ctx, conn)
    })
    
    return g.Wait()
}

总结

sync.WaitGroup 是最基础的并发同步原语，适用于简单并行场景，需要手动处理错误和资源管理。

errgroup.Group 是更高级的抽象，适合复杂场景，提供：

  • 自动错误传播
  • 上下文集成
  • 并发控制
  • 任务协调

选择建议：

  • 任务独立且简单 → sync.WaitGroup
  • 需要错误处理/任务协调 → errgroup.Group
  • 高并发简单任务 → sync.WaitGroup
  • 微服务/分布式系统 → errgroup.Group
  • 批处理/数据处理 → 两者结合使用
【Golang】使用Golang使用errorgroup
tr6666的博客
04-15 1187
在并发编程中，我们经常会遇到这样的场景：启动多个 goroutine 去并发处理任务，如果其中一个出错，其他的都应该被取消。在 Go 语言中，我们可以使用 errgroup 包来简化这种模式的实现。errgroup 提供了一种优雅的方式来处理并发任务中的错误。它允许我们并发执行多个任务，并在任何一个任务失败时取消所有任务。这可以帮助我们编写出更加健壮和易于理解的并发代码。如果你在使用 Go 进行并发编程，我强烈建议你试试 errgroup。
【Golang】WaitGroup 实现原理
tr6666的博客
12-02 1058
在并发编程中，协调多个 goroutine 的执行顺序和同步是一个常见的需求。Golang 提供了 sync.WaitGroup 来简化这一过程。WaitGroup 允许主 goroutine 等待一组 goroutine 完成工作。本文将详细介绍 sync.WaitGroup 的实现原理及其使用方法，帮助读者更好地理解和应用这一工具。1. 什么是 sync.WaitGroupsync.WaitGroup 是 Golang 标准库中的一个同步原语，用于等待一组 goroutine 完成。
Go同步原语之sync/waitGroup ---- 等待组
xjx的博客
09-01 1079
WaitGroup可以用于一个goroutine等待多个goroutine干活完成，也可以多个goroutine等待一个goroutine干活完成，是一个多对多的关系Add(n>0)方法应该在启动goroutine之前调用，然后在goroution内部调用Done方法WaitGroup必须在Wait方法返回之后才能再次使用Done只是Add的简单封装，所以实际上是可以通过一次加一个比较大的值减少调用，或者达到快速唤醒的目的。
Golang sync.WaitGroup
云满笔记
08-02 2014
WaitGroup 是开箱即用和并发安全的, 可以通过它很方便地实现一对多 goroutine 协作流程, 即: 一个分发子任务的 goroutine, 和多个执行子任务的 goroutine, 共同来完成一个较大的任务。在使用 WaitGroup 值的时候, 我们一定要注意, 千万不要让其中的计数器的值小于 0, 否则就会引发 panic。...
【golang】sync.WaitGroup详解
webxscan.com
11-15 3541
一、前言 Go语言在设计上对同步（Synchronization，数据同步和线程同步）提供大量的支持，比如 goroutine和channel同步原语，库层面有 - sync：提供基本的同步原语（比如Mutex、RWMutex、Locker）和 工具类（Once、WaitGroup、Cond、Pool、Map） - sync/atomic：提供变量的原子操作（基于硬件指令 compare-and-swap） -- 引用自《Golang package sync 剖析(一)： sync.On
Go语言sync.WaitGroup与errgroup.Group用法详解
bocai_xiaodaidai的博客
10-31 931
特性错误处理支持，返回第一个错误并中止其他任务不支持，需手动处理中止机制出现错误后可中止其他任务不支持适合场景并发任务中需统一错误处理仅需等待所有任务完成代码简洁性更简洁，内置错误处理需要手动处理错误和并发访问控制底层实现基于进一步封装基础并发任务等待工具选择哪种方式取决于需求，若并发任务中需要统一的错误捕获和中止机制，是更好的选择；若仅需等待所有任务执行完毕，可使用。
【Go】扩展并发原语之errgroup.Group的实战与源码解读
TomCN0803的博客
01-31 1611
虽然提供了对错误的返回，但是只能返回所有启动的 goroutine 产生的第一个错误，如果不做额外扩展的话后面所产生的错误都会被丢弃，然而在很多时候，获取每个 goroutine 的错误情况又是很必要的。是将输入文本转化为可读 channel，后三者则分别对应了 MapReduce 的三个步骤，它们每个步骤所产生的 channel 都作为下一步操作的输入 channel，会将数据全部存于内存中，在实际生产中可能会遇到很大的文件，这时候我们就需要考虑其它的堆实现方式了，不过这不是本文的重点。
go errgroup 用法示例
papaya的博客
07-23 9944
Go团队在实验仓库中添加了一个名为sync.errgroup的新软件包。 sync.ErrGroup再sync.WaitGroup功能的基础上，增加了错误传递，以及在发生不可恢复的错误时取消整个goroutine集合，或者等待超时 其中包含的函数如下： func WithContext(ctx context.Context) (*Group, context.Context) Go(...
golang基于errgroup实现并发调用
夏日白云的boke
09-03 1460
本文介绍了Golang中errgroup的使用场景及方法
Golang 标准库 tips -- waitgroup
GeekDavis 的博客
07-21 731
WaitGroup 用于线程同步，很多场景下为了提高并发需要开多个协程执行，但是又需要等待多个协程的结果都返回的情况下才进行后续逻辑处理，这种情况下可以通过 WaitGroup 提供的方法阻塞主线程的执行，直到所有的 goroutine 执行完成。 本文目录结构： WaitGroup 不能被值拷贝 Add 需要在 Wait 之前调用 使用 channel 实现 WaitGroup 的功能 Add 和 Done 数量问题 WaitGroup 和 channel 控制并发数 WaitGroup 和 channe
golang中的errgroup
liuyuede123的博客
10-08 1279
假如我们需要查询一个课件列表，其中有课件的信息，还有课件创建者的信息，和课件的缩略图信息。但是此时我们已经对服务做了拆分，假设有课件服务和用户服务还有文件服务。 我们通常的做法是，当我们查询课件列表时，我们首先调用课件服务，比如查询10条课件记录，然后获取到课件的创建人ID，课件的缩略图ID；再通过这些创建人ID去用户服务查询用户信息，通过缩略图ID去文件服务查询文件信息；然后再写到这10条课件记录中返回给前端。
Golang sync.WaitGroup 快速上手
Doublelv 的博客专栏。
07-12 5693
sync.WaitGroup 用于阻塞等待一组 Go 程的结束。主 Go 程调用 Add() 来设置等待的 Go 程数，然后该组中的每个 Go 程都需要在运行结束时调用 Done()， 递减 WaitGroup 的 Go 程计数器 counter。当 counter 变为 0 时，主 Go 程被唤醒继续执行。// 设置需要等待的 Go 程数量。// Go 程计数器减 1。// 阻塞等待所有 Go 程结束（等待 Go 程计数器变为 0）。
golang 详解协程——errgroup
dz45693的专栏
11-04 960
sync.ErrGroup再sync.WaitGroup功能的基础上，增加了错误传递，以及在发生不可恢复的错误时取消整个goroutine集合，或者等待超时。go支持并发，一般采用的是 channel 、 sync.WaitGroup 、context，来实现各个协程之间的流程控制和消息传递。上面这个例子是简单的利用 errgroup 进行的 waitGroup和error的处理，下面我们对关键的代码做一个分析，并结合源码来看。声明一个 group的实例，我们看下 group 包含哪些东西。
golang errgroup的用法及用处
热门推荐
程序员面试精选【codeoffer】
10-12 1万+
一般在golang 中想要并发运行业务时会直接开goroutine，关键字go ,但是直接go的话函数是无法对返回数据进行处理error的。 解决方案： ## 初级版本： 一般是直接在出错的地方打入log日志,将出的错误记录到日志文件中，也可以集合日志收集系统直接将该错误用邮箱或者办公软件发送给你如：钉钉机器人+graylog. ## 中级版本 当然你也可以自己在log包里封装好可以接受channel。 利用channel通道，将go中出现的error传入到封装好的带有channel接受器..
详解并发编程包之 Go errgroup
EDDYCJY的博客
08-23 826
欢迎大家点击上方文字「Golang梦工厂」关注公众号，设为星标，第一时间接收推送文章。前言哈喽，大家好，我是asong，今天给大家介绍一个并发编程包errgroup，其实这个包就是对syn...
2024年Go waitgroup和errgroup学习_go errgroup waitgroup，写给C C++开发的小程序布局指南
2401_84975828的博客
05-13 393
derived ctx被取消的场景：1. 传递给Go方法的函数第一次返回non-nil 2. Wait第一次返回时non-nil。函数一直被阻塞，直到所有go routine返回，或者第一个non-nil错误返回。返回一个新的group以及一个derived ctx。第一次报错则取消g，错误通过Wait方法返回。启动一个新的go routine执行f函数。
Go waitgroup和errgroup学习_go errgroup waitgroup
最新发布
2401_89172797的博客
12-20 206
derived ctx被取消的场景：1. 传递给Go方法的函数第一次返回non-nil 2. Wait第一次返回时non-nil。函数一直被阻塞，直到所有go routine返回，或者第一个non-nil错误返回。返回一个新的group以及一个derived ctx。第一次报错则取消g，错误通过Wait方法返回。启动一个新的go routine执行f函数。
go errgroup.group
shunuanwei的博客
12-27 502
在go的并发情况下，我们可能会经常用到的一个数据类型：sync.WaitGroup；经常用到的方法也是 Add，Done，Wait。可以看到，这个升级版是包含 waitgroup的，所以升级版也是能使用waitgroup的方法，恰好今天记录一个waitGroup的升级版errgroup.group。我们在看一个简单使用：官网上的。差不多了，看完在讨论。
Golang开发--sync.WaitGroup
liulanba的博客
09-25 651
通过这种方式，我们可以实现等待所有 goroutine 完成的效果：每个 goroutine 在完成任务后调用 Done 方法，计数器 counter 减少，直到最后一个 goroutine 完成任务并将计数器减少到零，从而释放阻塞在
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值