首页 golang

#sync.WaitGroup 完全指南

🎯 学习目标：深度掌握 Go 语言并发等待组机制，从基础概念到生产级实践

# 🧭 快速导航

# 🎯 核心概念

# 定义与本质

sync.WaitGroup 是 Go 并发编程的核心工具，实现了等待 - 聚合模式（Wait-Gather Pattern）。

graph TD
    A[主Goroutine] --> B[创建WaitGroup]
    B --> C[启动多个子Goroutine]
    C --> D[子Goroutine执行任务]
    D --> E[调用Done方法]
    E --> F[主Goroutine Wait阻塞]
    F --> G[所有任务完成]
    G --> H[主Goroutine被唤醒]
    H --> I[继续执行后续逻辑]

# 🔄 Go 并发生态系统

Go并发工具链
├── 基础原语
│   ├── goroutine (协程)
│   └── channel (通道)
├── 同步原语
│   ├── sync.Mutex (互斥锁)
│   ├── sync.RWMutex (读写锁)
│   ├── sync.WaitGroup (等待组) ← 本文重点
│   └── sync.Cond (条件变量)
├── 上下文管理
│   └── context (上下文)
└── 原子操作
    └── sync/atomic

# 核心 API 一览

方法 签名 功能 调用时机 并发安全性
Add(n int) 计数器 + n 注册 n 个待执行任务 主 goroutine ✅
Done() 计数器 - 1 标记一个任务完成 子 goroutine ✅
Wait() 阻塞等待 等待所有任务完成 主 goroutine ✅

# 🏗️ 基础用法

# 标准使用模式

// ✅ 推荐的标准模式
func StandardPattern() {
    var wg sync.WaitGroup
    taskCount := 5
    
    // 1. 预先注册所有任务
    wg.Add(taskCount)
    
    // 2. 启动并发任务
    for i := 0; i < taskCount; i++ {
        go func(id int) {
            defer wg.Done() // 3. 确保任务完成时调用 Done
            
            // 业务逻辑
            fmt.Printf("Task %d completed\n", id)
            time.Sleep(time.Second)
        }(i)
    }
    
    // 4. 等待所有任务完成
    wg.Wait()
    fmt.Println("All tasks completed!")
}

# 🚫 常见错误模式分析

# 错误 1：Add/Wait 时序混乱

// ❌ 危险！可能导致 race condition
func BadPattern1() {
    var wg sync.WaitGroup
    
    for i := 0; i < 10; i++ {
        go func() {
            wg.Add(1) // 🚨 在子 goroutine 中 Add
            defer wg.Done()
            // work...
        }()
    }
    
    wg.Wait() // 可能在 Add 之前执行，导致直接返回
}
// ✅ 正确修复
func GoodPattern1() {
    var wg sync.WaitGroup
    
    for i := 0; i < 10; i++ {
        wg.Add(1) // ✅ 在主 goroutine 中 Add
        go func() {
            defer wg.Done()
            // work...
        }()
    }
    wg.Wait()
}
# 错误 2：计数器不匹配


// ❌ 会导致 panic: negative WaitGroup counter
func BadPattern2() {
    var wg sync.WaitGroup
    wg.Add(2)
    
    go func() { defer wg.Done(); /* work1 */ }()
    go func() { defer wg.Done(); /* work2 */ }()
    go func() { defer wg.Done(); /* work3 */ }() // 🚨 多了一个 Done
    
    wg.Wait()
}
# 错误 3：重用 WaitGroup


// ❌ 可能导致 panic: WaitGroup is reused
func BadPattern3() {
    var wg sync.WaitGroup
    
    // 第一轮使用
    wg.Add(1)
    go func() { defer wg.Done(); /* work */ }()
    wg.Wait()
    
    // 🚨 立即重用可能有问题
    wg.Add(1)
    go func() { defer wg.Done(); /* work */ }()
    wg.Wait()
}


# ⚡ 高级实践


# 🔄 动态任务管理


// 动态添加任务的安全模式
type TaskManager struct {
    wg     sync.WaitGroup
    active atomic.Bool
}
func NewTaskManager() *TaskManager {
    tm := &TaskManager{}
    tm.active.Store(true)
    return tm
}
func (tm *TaskManager) AddTask(task func()) bool {
    if !tm.active.Load() {
        return false // 不再接受新任务
    }
    
    tm.wg.Add(1)
    go func() {
        defer tm.wg.Done()
        task()
    }()
    return true
}
func (tm *TaskManager) Wait() {
    tm.active.Store(false) // 停止接受新任务
    tm.wg.Wait()
}
// 进一步优化：使用 atomic 操作完全避免锁
type OptimizedTaskManager struct {
    wg     sync.WaitGroup
    active atomic.Bool
    count  atomic.Int64  // 跟踪活跃任务数
}
func NewOptimizedTaskManager() *OptimizedTaskManager {
    tm := &OptimizedTaskManager{}
    tm.active.Store(true)
    return tm
}
func (tm *OptimizedTaskManager) AddTask(task func()) bool {
    if !tm.active.Load() {
        return false
    }
    
    tm.wg.Add(1)
    tm.count.Add(1)
    
    go func() {
        defer func() {
            tm.wg.Done()
            tm.count.Add(-1)
        }()
        task()
    }()
    return true
}
func (tm *OptimizedTaskManager) Wait() {
    tm.active.Store(false)
    tm.wg.Wait()
}
func (tm *OptimizedTaskManager) ActiveCount() int64 {
    return tm.count.Load()
}
# 📊 数据聚合进阶方案


# 方案 A：Channel + WaitGroup（推荐）


func DataAggregationV1[T any](tasks []func() T) []T {
    results := make([]T, len(tasks))
    var wg sync.WaitGroup
    
    for i, task := range tasks {
        wg.Add(1)
        go func(index int, fn func() T) {
            defer wg.Done()
            results[index] = fn() // 按索引存储，避免竞态
        }(i, task)
    }
    
    wg.Wait()
    return results
}
# 方案 B：错误处理版本


type TaskResult[T any] struct {
    Value T
    Error error
    Index int
}
func DataAggregationV2[T any](tasks []func() (T, error)) []TaskResult[T] {
    results := make([]TaskResult[T], len(tasks))
    var wg sync.WaitGroup
    
    for i, task := range tasks {
        wg.Add(1)
        go func(index int, fn func() (T, error)) {
            defer wg.Done()
            value, err := fn()
            results[index] = TaskResult[T]{
                Value: value,
                Error: err,
                Index: index,
            }
        }(i, task)
    }
    
    wg.Wait()
    return results
}
# 方案 C：流式处理版本


func StreamProcessing[T, R any](
    input <-chan T,
    processor func(T) R,
    workerCount int,
) <-chan R {
    output := make(chan R, workerCount)
    var wg sync.WaitGroup
    
    // 启动工作池
    for i := 0; i < workerCount; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            for item := range input {
                output <- processor(item)
            }
        }()
    }
    
    // 监控完成状态
    go func() {
        wg.Wait()
        close(output)
    }()
    
    return output
}
# 🏭 生产级应用模式


# 服务优雅关闭


type GracefulServer struct {
    wg       sync.WaitGroup
    shutdown chan struct{}
    services []Service
}
type Service interface {
    Start() error
    Stop() error
}
func (s *GracefulServer) Start() error {
    for _, service := range s.services {
        s.wg.Add(1)
        go func(svc Service) {
            defer s.wg.Done()
            
            if err := svc.Start(); err != nil {
                log.Printf("Service start failed: %v", err)
            }
            
            <-s.shutdown // 等待关闭信号
            
            if err := svc.Stop(); err != nil {
                log.Printf("Service stop failed: %v", err)
            }
        }(service)
    }
    return nil
}
func (s *GracefulServer) Shutdown(ctx context.Context) error {
    close(s.shutdown)
    
    done := make(chan struct{})
    go func() {
        s.wg.Wait()
        close(done)
    }()
    
    select {
    case <-done:
        return nil
    case <-ctx.Done():
        return ctx.Err()
    }
}


# 🔬 源码剖析


# 数据结构深度解析


type WaitGroup struct {
    noCopy noCopy
  	// 状态字段，使用原子操作进行访问
    // 位布局（从高位到低位）：
    //   bits [0:32]  计数器 (counter) - 表示当前等待完成的 goroutine 数量
    //   bits [32]    标志位: synctest bubble membership（测试相关标志）
    //   bits [33:64] 等待计数 (wait count) - 表示当前阻塞在 Wait 上的 goroutine 数量
    state atomic.Uint64 
    sema  uint32  // 信号量，用于实现阻塞和唤醒机制
}
# state1 字段位布局


┌─────────────────────────────────┬─────────────────────────────────┐
│          高31位+1位标志位        │          低32位                  │
│     等待者数量 (waiter) + flag   │   当前未完成的goroutine数量        │
│  被Wait方法阻塞的goroutine数量    │  Add注册的待完成任务数             │
└─────────────────────────────────┴─────────────────────────────────┘



# 核心方法源码解析


# Add 方法流程图


flowchart TD
    A[Add delta] --> B[获取state指针]
    B --> C[原子操作: state += delta<<32]
    C --> D[提取counter和waiter]
    D --> E{counter < 0?}
    E -->|是| F[panic: negative counter]
    E -->|否| G{waiter > 0 且首次Add?}
    G -->|是| H[panic: Add与Wait并发]
    G -->|否| I{counter > 0 或 waiter == 0?}
    I -->|是| J[直接返回]
    I -->|否| K[重置state并唤醒所有waiter]


# 关键源码注释版


func (wg *WaitGroup) Add(delta int) {
	bubbled := false
	if synctest.IsInBubble() {
		// If Add is called from within a bubble, then all Add calls must be made
		// from the same bubble.
		switch synctest.Associate(wg) {
		case synctest.Unbubbled:
		case synctest.OtherBubble:
			// wg is already associated with a different bubble.
			fatal("sync: WaitGroup.Add called from multiple synctest bubbles")
		case synctest.CurrentBubble:
			bubbled = true
			state := wg.state.Or(waitGroupBubbleFlag)
			if state != 0 && state&waitGroupBubbleFlag == 0 {
				// Add has been called from outside this bubble.
				fatal("sync: WaitGroup.Add called from inside and outside synctest bubble")
			}
		}
	}
  // 原子更新 state
	state := wg.state.Add(uint64(delta) << 32)
	if state&waitGroupBubbleFlag != 0 && !bubbled {
		// Add has been called from within a synctest bubble (and we aren't in one).
		fatal("sync: WaitGroup.Add called from inside and outside synctest bubble")
	}
  // 位运算提取计数器和等待着数量
	v := int32(state >> 32)
	w := uint32(state & 0x7fffffff)
	if race.Enabled && delta > 0 && v == int32(delta) {
		// The first increment must be synchronized with Wait.
		// Need to model this as a read, because there can be
		// several concurrent wg.counter transitions from 0.
		race.Read(unsafe.Pointer(&wg.sema))
	}
	if v < 0 {
		panic("sync: negative WaitGroup counter")
	}
	if w != 0 && delta > 0 && v == int32(delta) {
		panic("sync: WaitGroup misuse: Add called concurrently with Wait")
	}
	if v > 0 || w == 0 {
		return
	}
	// This goroutine has set counter to 0 when waiters > 0.
	// Now there can't be concurrent mutations of state:
	// - Adds must not happen concurrently with Wait,
	// - Wait does not increment waiters if it sees counter == 0.
	// Still do a cheap sanity check to detect WaitGroup misuse.
	if wg.state.Load() != state {
		panic("sync: WaitGroup misuse: Add called concurrently with Wait")
	}
	// Reset waiters count to 0.
	wg.state.Store(0)
	if bubbled {
		// Adds must not happen concurrently with wait when counter is 0,
		// so we can safely disassociate wg from its current bubble.
		synctest.Disassociate(wg)
	}
	for ; w != 0; w-- {
		runtime_Semrelease(&wg.sema, false, 0)
	}
}
# 性能特征分析






特征
说明
影响






原子操作
使用 CAS 避免锁竞争
高性能并发




位运算优化
单个 64 位存储两个 32 位值
减少内存占用




信号量机制
基于运行时调度器
高效的阻塞 / 唤醒




自旋优化
Wait 方法中的自旋检查
减少不必要的阻塞








# 🎨 设计模式


# 1. 扇出模式 (Fan-Out)


func FanOut[T, R any](
    input T,
    processors []func(T) R,
) []R {
    results := make([]R, len(processors))
    var wg sync.WaitGroup
    
    for i, processor := range processors {
        wg.Add(1)
        go func(idx int, proc func(T) R) {
            defer wg.Done()
            results[idx] = proc(input)
        }(i, processor)
    }
    
    wg.Wait()
    return results
}
# 2. 工作池模式 (Worker Pool)


type WorkerPool[T, R any] struct {
    workerCount int
    taskCh      chan T
    resultCh    chan R
    wg          sync.WaitGroup
}
func NewWorkerPool[T, R any](
    workerCount int,
    processor func(T) R,
) *WorkerPool[T, R] {
    p := &WorkerPool[T, R]{
        workerCount: workerCount,
        taskCh:      make(chan T),
        resultCh:    make(chan R),
    }
    
    // 启动工作者
    for i := 0; i < workerCount; i++ {
        p.wg.Add(1)
        go func() {
            defer p.wg.Done()
            for task := range p.taskCh {
                p.resultCh <- processor(task)
            }
        }()
    }
    
    return p
}
func (p *WorkerPool[T, R]) Submit(task T) {
    p.taskCh <- task
}
func (p *WorkerPool[T, R]) Results() <-chan R {
    return p.resultCh
}
func (p *WorkerPool[T, R]) Close() {
    close(p.taskCh)
    p.wg.Wait()
    close(p.resultCh)
}
# 3. 管道模式 (Pipeline)


type Pipeline[T any] struct {
    stages []func(<-chan T) <-chan T
    wg     sync.WaitGroup
}
func NewPipeline[T any](stages ...func(<-chan T) <-chan T) *Pipeline[T] {
    return &Pipeline[T]{stages: stages}
}
func (p *Pipeline[T]) Process(input <-chan T) <-chan T {
    current := input
    
    for _, stage := range p.stages {
        current = p.runStage(stage, current)
    }
    
    return current
}
func (p *Pipeline[T]) runStage(
    stage func(<-chan T) <-chan T,
    input <-chan T,
) <-chan T {
    p.wg.Add(1)
    output := stage(input)
    
    go func() {
        defer p.wg.Done()
        // 等待 stage 处理完成
        for range output {
        }
    }()
    
    return output
}
func (p *Pipeline[T]) Wait() {
    p.wg.Wait()
}
# 4. 现代并发控制器


// 使用现代 atomic 类型的高性能并发控制器
type ModernConcurrencyController struct {
    wg          sync.WaitGroup
    active      atomic.Bool
    maxWorkers  atomic.Int64
    currentWork atomic.Int64
    config      atomic.Pointer[ControllerConfig]
}
type ControllerConfig struct {
    MaxConcurrency int64
    Timeout        time.Duration
    RetryCount     int
}
func NewModernConcurrencyController() *ModernConcurrencyController {
    ctrl := &ModernConcurrencyController{}
    ctrl.active.Store(true)
    ctrl.maxWorkers.Store(10) // 默认最大并发数
    return ctrl
}
func (mcc *ModernConcurrencyController) Execute(task func() error) error {
    if !mcc.active.Load() {
        return fmt.Errorf("controller is not active")
    }
    
    // 检查并发限制
    if mcc.currentWork.Load() >= mcc.maxWorkers.Load() {
        return fmt.Errorf("max concurrency reached")
    }
    
    mcc.wg.Add(1)
    mcc.currentWork.Add(1)
    
    go func() {
        defer func() {
            mcc.wg.Done()
            mcc.currentWork.Add(-1)
        }()
        
        task() // 执行任务
    }()
    
    return nil
}
func (mcc *ModernConcurrencyController) SetConfig(cfg *ControllerConfig) {
    mcc.config.Store(cfg)
    mcc.maxWorkers.Store(cfg.MaxConcurrency)
}
func (mcc *ModernConcurrencyController) GetStats() map[string]int64 {
    return map[string]int64{
        "active_workers": mcc.currentWork.Load(),
        "max_workers":    mcc.maxWorkers.Load(),
    }
}
func (mcc *ModernConcurrencyController) Shutdown() {
    mcc.active.Store(false)
    mcc.wg.Wait()
}


# 📊 性能优化


# 现代 atomic 类型优势


现代 Go 的 atomic 类型提供了更好的性能和易用性：


// 性能对比：传统 vs 现代 atomic
type PerformanceComparison struct {
    // 传统方式
    oldCounter int64
    oldFlag    int32
    
    // 现代方式 - 类型安全，性能更优
    counter atomic.Int64
    flag    atomic.Bool
    config  atomic.Pointer[Config]
}
func (p *PerformanceComparison) TraditionalUpdate() {
    atomic.AddInt64(&p.oldCounter, 1)
    atomic.StoreInt32(&p.oldFlag, 1)
}
func (p *PerformanceComparison) ModernUpdate() {
    p.counter.Add(1)
    p.flag.Store(true)
}
# 基准测试对比


// 传统方式：使用 channel
func BenchmarkChannel(b *testing.B) {
    for i := 0; i < b.N; i++ {
        ch := make(chan struct{}, 100)
        
        for j := 0; j < 100; j++ {
            go func() {
                // 模拟工作
                time.Sleep(time.Microsecond)
                ch <- struct{}{}
            }()
        }
        
        for j := 0; j < 100; j++ {
            <-ch
        }
    }
}
// 优化方式：使用 WaitGroup
func BenchmarkWaitGroup(b *testing.B) {
    for i := 0; i < b.N; i++ {
        var wg sync.WaitGroup
        
        for j := 0; j < 100; j++ {
            wg.Add(1)
            go func() {
                defer wg.Done()
                // 模拟工作
                time.Sleep(time.Microsecond)
            }()
        }
        
        wg.Wait()
    }
}
// 现代方式：使用 atomic 类型
func BenchmarkModernAtomic(b *testing.B) {
    for i := 0; i < b.N; i++ {
        var wg sync.WaitGroup
        var counter atomic.Int64
        
        for j := 0; j < 100; j++ {
            wg.Add(1)
            go func() {
                defer wg.Done()
                // 模拟工作
                time.Sleep(time.Microsecond)
                counter.Add(1)
            }()
        }
        
        wg.Wait()
    }
}
# 性能优化建议


# 1. 批量 Add 操作


// ❌ 低效：多次调用 Add (1)
for i := 0; i < 1000; i++ {
    wg.Add(1)
    go work()
}
// ✅ 高效：一次调用 Add (n)
wg.Add(1000)
for i := 0; i < 1000; i++ {
    go work()
}
# 2. 预分配资源


// ✅ 预分配结果切片
results := make([]Result, taskCount)
var wg sync.WaitGroup
wg.Add(taskCount)
for i := 0; i < taskCount; i++ {
    go func(index int) {
        defer wg.Done()
        results[index] = processTask(index)
    }(i)
}
wg.Wait()
# 3. 避免不必要的锁竞争


// ✅ 使用局部变量减少共享状态
func ProcessBatches(batches [][]Task) {
    var wg sync.WaitGroup
    
    for _, batch := range batches {
        wg.Add(1)
        go func(localBatch []Task) {
            defer wg.Done()
            
            // 在 goroutine 内部处理批次
            for _, task := range localBatch {
                task.Process()
            }
        }(batch)
    }
    
    wg.Wait()
}


# 🛠️ 实战技巧


# 1. 超时控制


func WaitWithTimeout(wg *sync.WaitGroup, timeout time.Duration) error {
    done := make(chan struct{})
    
    go func() {
        wg.Wait()
        close(done)
    }()
    
    select {
    case <-done:
        return nil
    case <-time.After(timeout):
        return fmt.Errorf("timeout after %v", timeout)
    }
}
# 2. 错误聚合


type ErrorGroup struct {
    wg   sync.WaitGroup
    mu   sync.Mutex
    errs []error
}
func (g *ErrorGroup) Go(f func() error) {
    g.wg.Add(1)
    go func() {
        defer g.wg.Done()
        if err := f(); err != nil {
            g.mu.Lock()
            g.errs = append(g.errs, err)
            g.mu.Unlock()
        }
    }()
}
func (g *ErrorGroup) Wait() []error {
    g.wg.Wait()
    return g.errs
}
// 优化版本：使用 atomic 操作减少锁竞争
type OptimizedErrorGroup struct {
    wg     sync.WaitGroup
    errs   atomic.Pointer[[]error]
    errCh  chan error
}
func NewOptimizedErrorGroup() *OptimizedErrorGroup {
    eg := &OptimizedErrorGroup{
        errCh: make(chan error, 100), // 缓冲通道
    }
    eg.errs.Store(&[]error{})
    return eg
}
func (g *OptimizedErrorGroup) Go(f func() error) {
    g.wg.Add(1)
    go func() {
        defer g.wg.Done()
        if err := f(); err != nil {
            select {
            case g.errCh <- err:
            default: // 非阻塞发送
            }
        }
    }()
}
func (g *OptimizedErrorGroup) Wait() []error {
    go func() {
        g.wg.Wait()
        close(g.errCh)
    }()
    
    var errs []error
    for err := range g.errCh {
        errs = append(errs, err)
    }
    return errs
}
# 3. 可取消的等待组


type CancelableWaitGroup struct {
    wg     sync.WaitGroup
    cancel context.CancelFunc
    ctx    context.Context
}
func NewCancelableWaitGroup(parent context.Context) *CancelableWaitGroup {
    ctx, cancel := context.WithCancel(parent)
    return &CancelableWaitGroup{
        ctx:    ctx,
        cancel: cancel,
    }
}
func (cwg *CancelableWaitGroup) Add(delta int) {
    cwg.wg.Add(delta)
}
func (cwg *CancelableWaitGroup) Done() {
    cwg.wg.Done()
}
func (cwg *CancelableWaitGroup) Wait() error {
    done := make(chan struct{})
    go func() {
        cwg.wg.Wait()
        close(done)
    }()
    
    select {
    case <-done:
        return nil
    case <-cwg.ctx.Done():
        return cwg.ctx.Err()
    }
}
func (cwg *CancelableWaitGroup) Cancel() {
    cwg.cancel()
}


# 🔍 调试与监控


# 调试技巧


# 1. 添加调试日志


type DebugWaitGroup struct {
    sync.WaitGroup
    name    string
    counter atomic.Int64
    logger  *log.Logger
}
func NewDebugWaitGroup(name string) *DebugWaitGroup {
    return &DebugWaitGroup{
        name:   name,
        logger: log.New(os.Stdout, fmt.Sprintf("[%s] ", name), log.LstdFlags),
    }
}
func (dwg *DebugWaitGroup) Add(delta int) {
    newCounter := dwg.counter.Add(int64(delta))
    dwg.logger.Printf("Add(%d) -> counter: %d", delta, newCounter)
    dwg.WaitGroup.Add(delta)
}
func (dwg *DebugWaitGroup) Done() {
    newCounter := dwg.counter.Add(-1)
    dwg.logger.Printf("Done() -> counter: %d", newCounter)
    dwg.WaitGroup.Done()
}
func (dwg *DebugWaitGroup) Wait() {
    dwg.logger.Printf("Wait() started with counter: %d", dwg.counter.Load())
    dwg.WaitGroup.Wait()
    dwg.logger.Printf("Wait() completed")
}
# 2. 检测泄露


func DetectGoroutineLeak(t *testing.T, fn func()) {
    before := runtime.NumGoroutine()
    fn()
    
    // 给 goroutine 一些时间完成
    time.Sleep(100 * time.Millisecond)
    runtime.GC()
    
    after := runtime.NumGoroutine()
    if after > before {
        t.Errorf("Possible goroutine leak: before=%d, after=%d", before, after)
    }
}


# 📈 最佳实践清单


# ✅ DO（推荐做法）


    

    • 

    • 

    • 

    • 

    • 

    • 



# ❌ DON'T（避免的做法）


    

    • 

    • 

    • 

    • 

    • 

    • 





# 🎓 进阶学习路径


# 推荐阅读顺序


    

  1. 基础并发概念 → goroutine 和 channel 机制
    2. 

  2. 同步原语对比 → Mutex vs RWMutex vs WaitGroup
    3. 

  3. context 包深入 → 超时和取消机制
    4. 

  4. 并发模式 → Pipeline, Fan-in/Fan-out, Worker Pool
    5. 

  5. 性能调优 → pprof 分析和优化技巧
    6. 



# 相关工具和库


//errgroup: 带错误处理的 WaitGroup
import "golang.org/x/sync/errgroup"
//semaphore: 信号量控制并发数
import "golang.org/x/sync/semaphore"
//singleflight: 防止重复调用
import "golang.org/x/sync/singleflight"
// 现代 atomic 类型
import "sync/atomic"
//atomic 类型示例
var (
    counter atomic.Int64
    flag    atomic.Bool
    value   atomic.Pointer[string]  // 泛型 atomic.Pointer
    u32     atomic.Uint32
    u64     atomic.Uint64
)


# 📝 总结


sync.WaitGroup 是 Go 并发编程的重要基石，它提供了一种优雅的方式来协调多个 goroutine 的执行。通过掌握其核心原理、使用模式和最佳实践，我们可以构建出高效、可靠的并发程序。


# 核心要点回顾


    

  1. 设计哲学：简单、安全、高性能
    2. 

  2. 使用原则：Add 在前、Done 在后、Wait 在最后
    3. 

  3. 性能特征：基于原子操作和信号量的高效实现
    4. 

  4. 扩展能力：可与其他并发原语组合使用
    5. 

  5. 现代优化：使用 atomic 类型提升性能和安全性
    6. 



# 现代 Go 并发最佳实践


    

  • 优先使用 atomic 类型： atomic.Int64 、 atomic.Bool 、 atomic.Pointer[T]  等
    • 

  • 减少锁竞争：用 atomic 操作替代简单的互斥锁
    • 

  • 类型安全：利用泛型 atomic.Pointer 避免 unsafe 操作
    • 

  • 性能提升：现代 API 提供更好的性能和易用性
    • 



掌握 WaitGroup 不仅是学会一个工具，更是理解 Go 并发编程设计思想的重要一步。结合现代 atomic 类型，我们可以构建更加高效和安全的并发程序。






💡 学习建议：理论结合实践，多写代码多调试，逐步建立对 Go 并发编程的直觉理解。记住，优秀的并发程序不仅要求正确性，更要求清晰的设计和优雅的实现。




      

          
      

  


   


    

  
    
      
    
    更新于
    
  
  
      
        
      
      阅读次数
      
      次
  



      


  
  
请我喝[茶]~(￣▽￣)~*

  

      
      

        ZJM 微信支付
        
微信支付

      

      
      

        ZJM 支付宝
        
支付宝