处理错误 errgroup

1. 概述

errgroup 是 Go 语言标准库 golang.org/x/sync/errgroup 提供的一个包，用于管理一组并发任务并处理它们的错误。它在并发编程中非常有用，可以简化错误处理和任务管理的复杂性。

在整个 Go 语言课程体系中，errgroup 是并发编程的重要组成部分，与 Goroutine、Channel、同步原语等一起构成了 Go 语言并发模型的核心。掌握 errgroup 的使用方法，对于编写正确、可靠的并发程序至关重要。

2. 基本概念

2.1 语法

2.1.1 基本用法

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

func main() {
    g, ctx := errgroup.WithContext(context.Background())
    
    g.Go(func() error {
        // 执行任务 1
        return nil
    })
    
    g.Go(func() error {
        // 执行任务 2
        return nil
    })
    
    if err := g.Wait(); err != nil {
        fmt.Printf("Error: %v\n", err)
    }
}

2.1.2 示例代码

package main

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

func main() {
    g, ctx := errgroup.WithContext(context.Background())
    
    // 任务 1
    g.Go(func() error {
        select {
        case <-time.After(2 * time.Second):
            fmt.Println("Task 1 completed")
            return nil
        case <-ctx.Done():
            return ctx.Err()
        }
    })
    
    // 任务 2
    g.Go(func() error {
        time.Sleep(1 * time.Second)
        fmt.Println("Task 2 failed")
        return fmt.Errorf("task 2 error")
    })
    
    if err := g.Wait(); err != nil {
        fmt.Printf("Error: %v\n", err)
    }
    fmt.Println("All tasks completed")
}

2.2 语义

errgroup.Group：管理一组并发任务的结构体，提供 Go 方法添加任务，Wait 方法等待所有任务完成并返回第一个错误。
WithContext：创建一个带有上下文的 errgroup，当任何任务返回错误时，上下文会被取消。
Go：添加一个任务到 errgroup，任务是一个返回 error 的函数。
Wait：等待所有任务完成，返回第一个错误。
上下文取消：当任何任务返回错误时，errgroup 会取消上下文，通知其他任务停止执行。

2.3 规范

命名规范：变量和函数命名应清晰表达其用途，避免使用模糊的名称。
使用顺序：
1. 使用 errgroup.WithContext 创建一个带有上下文的 errgroup。
2. 使用 g.Go 添加并发任务。
3. 使用 g.Wait 等待所有任务完成并处理错误。
性能考虑：errgroup 适用于管理一组相关的并发任务，避免创建过多的 errgroup。
代码质量：
- 在任务函数中，应检查上下文是否被取消，及时退出。
- 错误处理应清晰明了，避免忽略错误。
- 任务函数应专注于单一职责，避免过于复杂。

3. 原理深度解析

3.1 errgroup 的原理

errgroup 的核心原理是：

任务管理：使用 WaitGroup 管理所有并发任务的执行状态。
错误传播：当任何任务返回错误时，立即捕获并存储第一个错误。
上下文取消：当任何任务返回错误时，取消上下文，通知其他任务停止执行。
等待机制：使用 WaitGroup 等待所有任务完成，然后返回第一个错误。

3.2 实现机制

errgroup.Group 的实现主要包含以下组件：

WaitGroup：用于等待所有任务完成。
errOnce：用于确保只捕获和存储第一个错误。
ctx：用于传递取消信号的上下文。
cancel：用于取消上下文的函数。

// 简化的 errgroup.Group 实现
type Group struct {
    wg sync.WaitGroup
    errOnce sync.Once
    err     error
    ctx     context.Context
    cancel  context.CancelFunc
}

func (g *Group) Go(f func() error) {
    g.wg.Add(1)
    go func() {
        defer g.wg.Done()
        if err := f(); err != nil {
            g.errOnce.Do(func() {
                g.err = err
                if g.cancel != nil {
                    g.cancel()
                }
            })
        }
    }()
}

func (g *Group) Wait() error {
    g.wg.Wait()
    return g.err
}

3.3 上下文管理

errgroup.WithContext 函数创建一个带有上下文的 errgroup，当任何任务返回错误时，上下文会被取消：

func WithContext(ctx context.Context) (*Group, context.Context) {
    ctx, cancel := context.WithCancel(ctx)
    return &Group{
        ctx:    ctx,
        cancel: cancel,
    }, ctx
}

这种机制确保了当一个任务失败时，其他任务可以及时收到取消信号并停止执行，避免不必要的资源消耗。

3.4 错误处理策略

errgroup 的错误处理策略是：

第一个错误优先：只返回第一个遇到的错误，忽略后续的错误。
立即取消：当遇到第一个错误时，立即取消上下文，通知其他任务停止执行。
等待所有任务：即使遇到错误，也会等待所有任务完成，确保资源得到正确释放。

3.5 适用场景

errgroup 适用于以下场景：

并行处理多个相关任务：需要同时执行多个任务，并且任何任务失败都应该导致整个操作失败。
错误传播：需要将错误从并发任务传播到主函数。
优雅取消：需要在一个任务失败时，取消其他正在执行的任务。

4. 常见错误与踩坑点

4.1 忽略上下文取消

错误表现：任务函数没有检查上下文是否被取消，导致即使其他任务失败，该任务仍继续执行，浪费资源。

产生原因：任务函数中没有使用 select 语句监听上下文的取消信号。

解决方案：在任务函数中使用 select 语句监听上下文的取消信号，当上下文被取消时，及时退出任务。

// 错误示例：忽略上下文取消
func task(ctx context.Context) error {
    // 长时间运行的任务
    time.Sleep(10 * time.Second)
    return nil
}

// 正确示例：检查上下文取消
func task(ctx context.Context) error {
    select {
    case <-time.After(10 * time.Second):
        return nil
    case <-ctx.Done():
        return ctx.Err()
    }
}

4.2 错误处理不当

错误表现：任务函数中的错误没有正确返回，导致 errgroup 无法捕获错误。

产生原因：任务函数中忽略了错误，或者错误返回逻辑不正确。

解决方案：确保任务函数正确返回所有错误，不要忽略任何错误。

// 错误示例：忽略错误
func task() error {
    _, err := os.Open("non-existent-file.txt")
    // 忽略错误
    return nil
}

// 正确示例：正确返回错误
func task() error {
    _, err := os.Open("non-existent-file.txt")
    return err
}

4.3 任务函数过于复杂

错误表现：任务函数过于复杂，包含多个职责，导致错误处理困难。

产生原因：任务函数设计不合理，违反了单一职责原则。

解决方案：将复杂任务拆分为多个简单任务，每个任务专注于单一职责。

// 错误示例：复杂任务函数
func complexTask(ctx context.Context) error {
    // 任务 1
    if err := doTask1(); err != nil {
        return err
    }
    
    // 任务 2
    if err := doTask2(); err != nil {
        return err
    }
    
    // 任务 3
    if err := doTask3(); err != nil {
        return err
    }
    
    return nil
}

// 正确示例：拆分为多个简单任务
func task1(ctx context.Context) error {
    return doTask1()
}

func task2(ctx context.Context) error {
    return doTask2()
}

func task3(ctx context.Context) error {
    return doTask3()
}

4.4 资源泄漏

错误表现：任务函数中打开的资源没有正确关闭，导致资源泄漏。

产生原因：任务函数中没有使用 defer 语句关闭资源，或者在上下文取消时没有及时释放资源。

解决方案：使用 defer 语句确保资源被正确关闭，即使在上下文取消的情况下。

// 错误示例：资源泄漏
func task(ctx context.Context) error {
    file, err := os.Open("file.txt")
    if err != nil {
        return err
    }
    // 没有关闭文件
    return processFile(file)
}

// 正确示例：使用 defer 关闭资源
func task(ctx context.Context) error {
    file, err := os.Open("file.txt")
    if err != nil {
        return err
    }
    defer file.Close()
    return processFile(file)
}

4.5 上下文传递不当

错误表现：任务函数没有使用 errgroup 提供的上下文，而是使用了原始上下文，导致无法收到取消信号。

产生原因：任务函数参数设计不合理，没有接收 errgroup 提供的上下文。

解决方案：确保任务函数接收并使用 errgroup 提供的上下文。

// 错误示例：使用原始上下文
func main() {
    g, ctx := errgroup.WithContext(context.Background())
    g.Go(func() error {
        return task(context.Background()) // 错误：使用了原始上下文
    })
    g.Wait()
}

// 正确示例：使用 errgroup 提供的上下文
func main() {
    g, ctx := errgroup.WithContext(context.Background())
    g.Go(func() error {
        return task(ctx) // 正确：使用了 errgroup 提供的上下文
    })
    g.Wait()
}

4.6 错误类型处理不当

错误表现：没有正确处理不同类型的错误，导致错误信息不明确。

产生原因：错误处理逻辑过于简单，没有区分不同类型的错误。

解决方案：使用错误包装和类型断言，正确处理不同类型的错误。

// 错误示例：错误处理过于简单
func task() error {
    if err := doSomething(); err != nil {
        return err
    }
    return nil
}

// 正确示例：使用错误包装
func task() error {
    if err := doSomething(); err != nil {
        return fmt.Errorf("doing something: %w", err)
    }
    return nil
}

5. 常见应用场景

5.1 并行处理多个 HTTP 请求

场景描述：需要并行发送多个 HTTP 请求，等待所有请求完成，并处理任何错误。

使用方法：使用 errgroup 管理多个并发的 HTTP 请求，当任何请求失败时，取消其他请求。

示例代码：

package main

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

func fetchURL(ctx context.Context, url string) error {
    req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
    if err != nil {
        return err
    }
    
    client := &http.Client{Timeout: 10 * time.Second}
    resp, err := client.Do(req)
    if err != nil {
        return err
    }
    defer resp.Body.Close()
    
    fmt.Printf("Fetched %s: %d\n", url, resp.StatusCode)
    return nil
}

func main() {
    urls := []string{
        "https://www.google.com",
        "https://www.github.com",
        "https://www.amazon.com",
    }
    
    g, ctx := errgroup.WithContext(context.Background())
    
    for _, url := range urls {
        url := url // 捕获循环变量
        g.Go(func() error {
            return fetchURL(ctx, url)
        })
    }
    
    if err := g.Wait(); err != nil {
        fmt.Printf("Error: %v\n", err)
    } else {
        fmt.Println("All requests completed successfully")
    }
}

5.2 并行处理文件

场景描述：需要并行处理多个文件，等待所有文件处理完成，并处理任何错误。

使用方法：使用 errgroup 管理多个并发的文件处理任务，当任何任务失败时，取消其他任务。

示例代码：

package main

import (
    "context"
    "fmt"
    "golang.org/x/sync/errgroup"
    "os"
    "path/filepath"
)

func processFile(ctx context.Context, filePath string) error {
    select {
    case <-ctx.Done():
        return ctx.Err()
    default:
        // 处理文件
        data, err := os.ReadFile(filePath)
        if err != nil {
            return err
        }
        fmt.Printf("Processed %s: %d bytes\n", filePath, len(data))
        return nil
    }
}

func main() {
    files := []string{
        "file1.txt",
        "file2.txt",
        "file3.txt",
    }
    
    g, ctx := errgroup.WithContext(context.Background())
    
    for _, file := range files {
        file := file // 捕获循环变量
        g.Go(func() error {
            return processFile(ctx, file)
        })
    }
    
    if err := g.Wait(); err != nil {
        fmt.Printf("Error: %v\n", err)
    } else {
        fmt.Println("All files processed successfully")
    }
}

5.3 并行数据库操作

场景描述：需要并行执行多个数据库操作，等待所有操作完成，并处理任何错误。

使用方法：使用 errgroup 管理多个并发的数据库操作，当任何操作失败时，取消其他操作。

示例代码：

package main

import (
    "context"
    "fmt"
    "golang.org/x/sync/errgroup"
    "database/sql"
    _ "github.com/go-sql-driver/mysql"
)

func queryDB(ctx context.Context, db *sql.DB, query string) error {
    select {
    case <-ctx.Done():
        return ctx.Err()
    default:
        rows, err := db.QueryContext(ctx, query)
        if err != nil {
            return err
        }
        defer rows.Close()
        
        var count int
        for rows.Next() {
            if err := rows.Scan(&count); err != nil {
                return err
            }
        }
        fmt.Printf("Query '%s' returned %d rows\n", query, count)
        return nil
    }
}

func main() {
    db, err := sql.Open("mysql", "user:password@tcp(localhost:3306)/dbname")
    if err != nil {
        fmt.Printf("Error opening database: %v\n", err)
        return
    }
    defer db.Close()
    
    queries := []string{
        "SELECT COUNT(*) FROM users",
        "SELECT COUNT(*) FROM orders",
        "SELECT COUNT(*) FROM products",
    }
    
    g, ctx := errgroup.WithContext(context.Background())
    
    for _, query := range queries {
        query := query // 捕获循环变量
        g.Go(func() error {
            return queryDB(ctx, db, query)
        })
    }
    
    if err := g.Wait(); err != nil {
        fmt.Printf("Error: %v\n", err)
    } else {
        fmt.Println("All database queries completed successfully")
    }
}

5.4 并行计算

场景描述：需要并行执行多个计算任务，等待所有任务完成，并处理任何错误。

使用方法：使用 errgroup 管理多个并发的计算任务，当任何任务失败时，取消其他任务。

示例代码：

package main

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

func calculate(ctx context.Context, x float64) error {
    select {
    case <-ctx.Done():
        return ctx.Err()
    default:
        // 执行计算
        result := math.Sqrt(x)
        fmt.Printf("Square root of %f is %f\n", x, result)
        return nil
    }
}

func main() {
    values := []float64{4, 9, 16, 25, 36}
    
    g, ctx := errgroup.WithContext(context.Background())
    
    for _, value := range values {
        value := value // 捕获循环变量
        g.Go(func() error {
            return calculate(ctx, value)
        })
    }
    
    if err := g.Wait(); err != nil {
        fmt.Printf("Error: %v\n", err)
    } else {
        fmt.Println("All calculations completed successfully")
    }
}

5.5 并行服务启动

场景描述：需要并行启动多个服务，等待所有服务启动完成，并处理任何错误。

使用方法：使用 errgroup 管理多个并发的服务启动任务，当任何服务启动失败时，取消其他服务的启动。

示例代码：

package main

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

func startServer(ctx context.Context, addr string, handler http.Handler) error {
    server := &http.Server{
        Addr:    addr,
        Handler: handler,
    }
    
    // 启动服务器
    go func() {
        if err := server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
            fmt.Printf("Server on %s failed: %v\n", addr, err)
        }
    }()
    
    // 等待上下文取消
    <-ctx.Done()
    
    // 优雅关闭服务器
    shutdownCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    defer cancel()
    
    if err := server.Shutdown(shutdownCtx); err != nil {
        return err
    }
    
    fmt.Printf("Server on %s stopped\n", addr)
    return nil
}

func main() {
    handlers := map[string]http.Handler{
        ":8080": http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            fmt.Fprintln(w, "Hello from server 1")
        }),
        ":8081": http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            fmt.Fprintln(w, "Hello from server 2")
        }),
    }
    
    g, ctx := errgroup.WithContext(context.Background())
    
    for addr, handler := range handlers {
        addr := addr
        handler := handler
        g.Go(func() error {
            return startServer(ctx, addr, handler)
        })
    }
    
    // 等待用户输入
    fmt.Println("Servers started. Press Enter to stop...")
    fmt.Scanln()
    
    // 取消上下文，停止所有服务器
    cancel()
    
    if err := g.Wait(); err != nil {
        fmt.Printf("Error: %v\n", err)
    } else {
        fmt.Println("All servers stopped successfully")
    }
}

6. 企业级进阶应用场景

6.1 微服务健康检查

场景描述：在企业级微服务架构中，需要并行检查多个服务的健康状态，当任何服务不健康时，快速失败。

使用方法：使用 errgroup 管理多个并发的健康检查任务，当任何服务健康检查失败时，取消其他检查。

示例代码：

package main

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

func checkHealth(ctx context.Context, service string, url string) error {
    req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
    if err != nil {
        return fmt.Errorf("checking %s health: %w", service, err)
    }
    
    client := &http.Client{Timeout: 5 * time.Second}
    resp, err := client.Do(req)
    if err != nil {
        return fmt.Errorf("checking %s health: %w", service, err)
    }
    defer resp.Body.Close()
    
    if resp.StatusCode != http.StatusOK {
        return fmt.Errorf("%s health check failed: status code %d", service, resp.StatusCode)
    }
    
    fmt.Printf("%s health check passed\n", service)
    return nil
}

func main() {
    services := map[string]string{
        "userservice": "http://localhost:8080/health",
        "orderservice": "http://localhost:8081/health",
        "paymentservice": "http://localhost:8082/health",
    }
    
    g, ctx := errgroup.WithContext(context.Background())
    
    for service, url := range services {
        service := service
        url := url
        g.Go(func() error {
            return checkHealth(ctx, service, url)
        })
    }
    
    if err := g.Wait(); err != nil {
        fmt.Printf("Health check failed: %v\n", err)
        // 处理健康检查失败的情况
    } else {
        fmt.Println("All services are healthy")
        // 继续正常操作
    }
}

6.2 数据ETL处理

场景描述：在企业级数据处理系统中，需要并行执行多个 ETL（提取、转换、加载）任务，当任何任务失败时，取消其他任务。

使用方法：使用 errgroup 管理多个并发的 ETL 任务，当任何任务失败时，取消其他任务。

示例代码：

package main

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

func etlTask(ctx context.Context, taskName string) error {
    select {
    case <-ctx.Done():
        return ctx.Err()
    default:
        fmt.Printf("Starting ETL task: %s\n", taskName)
        
        // 模拟 ETL 任务
        time.Sleep(2 * time.Second)
        
        // 模拟随机错误
        if taskName == "task3" {
            return fmt.Errorf("ETL task %s failed", taskName)
        }
        
        fmt.Printf("Completed ETL task: %s\n", taskName)
        return nil
    }
}

func main() {
    tasks := []string{
        "task1",
        "task2",
        "task3",
        "task4",
    }
    
    g, ctx := errgroup.WithContext(context.Background())
    
    for _, task := range tasks {
        task := task
        g.Go(func() error {
            return etlTask(ctx, task)
        })
    }
    
    if err := g.Wait(); err != nil {
        fmt.Printf("ETL process failed: %v\n", err)
        // 处理 ETL 失败的情况
    } else {
        fmt.Println("All ETL tasks completed successfully")
        // 继续正常操作
    }
}

6.3 分布式系统协调

场景描述：在分布式系统中，需要协调多个节点的操作，当任何节点操作失败时，取消其他节点的操作。

使用方法：使用 errgroup 管理多个并发的节点操作，当任何节点操作失败时，取消其他节点的操作。

示例代码：

package main

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

func nodeOperation(ctx context.Context, nodeID string) error {
    select {
    case <-ctx.Done():
        return ctx.Err()
    default:
        fmt.Printf("Starting operation on node %s\n", nodeID)
        
        // 模拟节点操作
        time.Sleep(1 * time.Second)
        
        // 模拟随机错误
        if nodeID == "node3" {
            return fmt.Errorf("Operation on node %s failed", nodeID)
        }
        
        fmt.Printf("Completed operation on node %s\n", nodeID)
        return nil
    }
}

func main() {
    nodes := []string{
        "node1",
        "node2",
        "node3",
        "node4",
    }
    
    g, ctx := errgroup.WithContext(context.Background())
    
    for _, node := range nodes {
        node := node
        g.Go(func() error {
            return nodeOperation(ctx, node)
        })
    }
    
    if err := g.Wait(); err != nil {
        fmt.Printf("Distributed operation failed: %v\n", err)
        // 处理分布式操作失败的情况
    } else {
        fmt.Println("All node operations completed successfully")
        // 继续正常操作
    }
}

6.4 批量 API 调用

场景描述：在企业级应用中，需要批量调用多个 API 接口，当任何 API 调用失败时，取消其他 API 调用。

使用方法：使用 errgroup 管理多个并发的 API 调用，当任何 API 调用失败时，取消其他 API 调用。

示例代码：

package main

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

func callAPI(ctx context.Context, apiName string, url string) error {
    req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
    if err != nil {
        return fmt.Errorf("calling %s API: %w", apiName, err)
    }
    
    client := &http.Client{Timeout: 3 * time.Second}
    resp, err := client.Do(req)
    if err != nil {
        return fmt.Errorf("calling %s API: %w", apiName, err)
    }
    defer resp.Body.Close()
    
    if resp.StatusCode != http.StatusOK {
        return fmt.Errorf("%s API call failed: status code %d", apiName, resp.StatusCode)
    }
    
    fmt.Printf("%s API call successful\n", apiName)
    return nil
}

func main() {
    apis := map[string]string{
        "user": "https://api.example.com/user",
        "order": "https://api.example.com/order",
        "payment": "https://api.example.com/payment",
    }
    
    g, ctx := errgroup.WithContext(context.Background())
    
    for apiName, url := range apis {
        apiName := apiName
        url := url
        g.Go(func() error {
            return callAPI(ctx, apiName, url)
        })
    }
    
    if err := g.Wait(); err != nil {
        fmt.Printf("API call failed: %v\n", err)
        // 处理 API 调用失败的情况
    } else {
        fmt.Println("All API calls completed successfully")
        // 继续正常操作
    }
}

6.5 并行测试执行

场景描述：在企业级测试框架中，需要并行执行多个测试用例，当任何测试用例失败时，取消其他测试用例。

使用方法：使用 errgroup 管理多个并发的测试用例，当任何测试用例失败时，取消其他测试用例。

示例代码：

package main

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

func runTest(ctx context.Context, testName string) error {
    select {
    case <-ctx.Done():
        return ctx.Err()
    default:
        fmt.Printf("Running test: %s\n", testName)
        
        // 模拟测试执行
        time.Sleep(1 * time.Second)
        
        // 模拟测试失败
        if testName == "test3" {
            return fmt.Errorf("Test %s failed", testName)
        }
        
        fmt.Printf("Test %s passed\n", testName)
        return nil
    }
}

func main() {
    tests := []string{
        "test1",
        "test2",
        "test3",
        "test4",
    }
    
    g, ctx := errgroup.WithContext(context.Background())
    
    for _, test := range tests {
        test := test
        g.Go(func() error {
            return runTest(ctx, test)
        })
    }
    
    if err := g.Wait(); err != nil {
        fmt.Printf("Test suite failed: %v\n", err)
        // 处理测试失败的情况
    } else {
        fmt.Println("All tests passed")
        // 继续正常操作
    }
}

7. 行业最佳实践

7.1 合理使用上下文

实践内容：在使用 errgroup 时，正确传递和使用上下文，确保任务能够及时响应取消信号。

推荐理由：上下文是 errgroup 实现取消机制的关键，正确使用上下文可以确保任务在不需要时及时停止，避免资源浪费。

示例：

任务函数应接收并使用 errgroup 提供的上下文。
在任务函数中使用 select 语句监听上下文的取消信号。
对于长时间运行的任务，应定期检查上下文是否被取消。

7.2 错误处理规范化

实践内容：使用错误包装和类型断言，确保错误信息清晰明了。

推荐理由：规范化的错误处理可以提高代码的可读性和可维护性，便于调试和问题定位。

示例：

使用 fmt.Errorf("%s: %w", message, err) 包装错误。
使用 errors.Is 和 errors.As 检查和处理特定类型的错误。
提供详细的错误信息，包括任务名称、操作类型等。

7.3 资源管理

实践内容：使用 defer 语句确保资源被正确释放，即使在上下文取消的情况下。

推荐理由：正确的资源管理可以避免资源泄漏，提高程序的可靠性和稳定性。

示例：

使用 defer 语句关闭文件、网络连接等资源。
在上下文取消时，确保资源被及时释放。
避免在任务函数中持有资源时间过长。

7.4 任务粒度控制

实践内容：合理控制任务的粒度，避免任务过大或过小。

推荐理由：合适的任务粒度可以提高并发效率，减少上下文切换开销。

示例：

将复杂任务拆分为多个简单任务，每个任务专注于单一职责。
避免创建过多的小任务，导致上下文切换开销过大。
根据任务的性质和执行时间，合理调整任务粒度。

7.5 错误传播策略

实践内容：根据业务需求，选择合适的错误传播策略。

推荐理由：不同的业务场景需要不同的错误传播策略，选择合适的策略可以提高系统的可靠性和用户体验。

示例：

对于关键任务，使用 errgroup 的默认策略，任何任务失败都导致整个操作失败。
对于非关键任务，可以使用自定义错误处理策略，允许部分任务失败。
对于需要收集所有错误的场景，可以使用自定义的错误收集机制。

7.6 监控和日志

实践内容：在任务执行过程中，添加适当的监控和日志，便于问题定位和性能分析。

推荐理由：监控和日志可以帮助发现和解决问题，提高系统的可观测性。

示例：

在任务开始和结束时记录日志。
记录任务的执行时间和结果。
使用监控系统跟踪任务的执行状态和性能指标。

7.7 测试覆盖

实践内容：为 errgroup 的使用编写充分的测试用例，确保代码的正确性。

推荐理由：充分的测试可以发现和预防问题，提高代码的质量和可靠性。

示例：

测试正常情况下的任务执行。
测试任务失败时的错误传播和上下文取消。
测试多个任务并发执行的情况。
测试资源泄漏和异常情况。

7.8 性能优化

实践内容：根据实际情况，优化 errgroup 的使用，提高并发性能。

推荐理由：性能优化可以提高系统的响应速度和吞吐量，改善用户体验。

示例：

合理控制并发任务的数量，避免过度并发。
对于 CPU 密集型任务，并发数量不宜超过 CPU 核心数。
对于 I/O 密集型任务，可以适当增加并发数量。
使用工作池模式，复用 Goroutine，减少 Goroutine 创建和销毁的开销。

8. 常见问题答疑（FAQ）

8.1 errgroup 与 WaitGroup 有什么区别？

问题描述：errgroup 和 WaitGroup 都是用于管理并发任务的工具，它们有什么区别？

回答内容：

WaitGroup：只负责等待所有任务完成，不处理错误。
errgroup：不仅等待所有任务完成，还会捕获和传播第一个错误，并且支持上下文取消。
使用场景：当需要处理错误时，使用 errgroup；当不需要处理错误时，使用 WaitGroup。

示例代码：

// 使用 WaitGroup
var wg sync.WaitGroup
for i := 0; i < 10; i++ {
    wg.Add(1)
    go func() {
        defer wg.Done()
        // 执行任务
    }()
}
wg.Wait()

// 使用 errgroup
g, ctx := errgroup.WithContext(context.Background())
for i := 0; i < 10; i++ {
    g.Go(func() error {
        // 执行任务
        return nil
    })
}
if err := g.Wait(); err != nil {
    // 处理错误
}

8.2 如何处理多个错误？

问题描述：errgroup 只返回第一个错误，如何处理多个错误？

回答内容：

errgroup 的设计理念是"快速失败"，当任何任务失败时，立即取消其他任务并返回第一个错误。
如果需要收集所有错误，可以使用自定义的错误收集机制，例如使用通道收集错误。

示例代码：

func main() {
    errors := make(chan error, 10)
    var wg sync.WaitGroup
    
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            if err := doTask(i); err != nil {
                errors <- err
            }
        }(i)
    }
    
    go func() {
        wg.Wait()
        close(errors)
    }()
    
    var errs []error
    for err := range errors {
        errs = append(errs, err)
    }
    
    if len(errs) > 0 {
        fmt.Printf("Got %d errors: %v\n", len(errs), errs)
    }
}

8.3 如何设置任务的超时时间？

问题描述：如何为 errgroup 中的任务设置超时时间？

回答内容：

使用 context.WithTimeout 创建一个带有超时的上下文。
将这个上下文传递给 errgroup.WithContext。

示例代码：

func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    defer cancel()
    
    g, ctx := errgroup.WithContext(ctx)
    
    g.Go(func() error {
        // 执行任务
        time.Sleep(10 * time.Second) // 超过超时时间
        return nil
    })
    
    if err := g.Wait(); err != nil {
        fmt.Printf("Error: %v\n", err) // 会返回 context.DeadlineExceeded 错误
    }
}

8.4 如何限制并发数量？

问题描述：如何限制 errgroup 中并发任务的数量？

回答内容：

使用通道作为信号量，限制并发任务的数量。
在添加任务到 errgroup 之前，先获取信号量。
任务完成后，释放信号量。

示例代码：

func main() {
    maxConcurrency := 3
    semaphore := make(chan struct{}, maxConcurrency)
    
    g, ctx := errgroup.WithContext(context.Background())
    
    for i := 0; i < 10; i++ {
        i := i
        semaphore <- struct{}{} // 获取信号量
        g.Go(func() error {
            defer func() { <-semaphore }() // 释放信号量
            fmt.Printf("Running task %d\n", i)
            time.Sleep(1 * time.Second)
            return nil
        })
    }
    
    if err := g.Wait(); err != nil {
        fmt.Printf("Error: %v\n", err)
    }
}

8.5 如何处理 panic？

问题描述：errgroup 中的任务发生 panic 时，会发生什么？如何处理？

回答内容：

errgroup 不会捕获任务中的 panic，panic 会导致整个程序崩溃。
为了防止程序崩溃，应该在任务函数中使用 recover 捕获 panic。

示例代码：

func main() {
    g, ctx := errgroup.WithContext(context.Background())
    
    g.Go(func() error {
        defer func() {
            if r := recover(); r != nil {
                fmt.Printf("Recovered from panic: %v\n", r)
            }
        }()
        
        // 可能发生 panic 的代码
        panic("task panic")
        return nil
    })
    
    if err := g.Wait(); err != nil {
        fmt.Printf("Error: %v\n", err)
    }
}

8.6 errgroup 的性能如何？

问题描述：errgroup 的性能如何？在高并发场景下是否适用？

回答内容：

errgroup 的性能开销很小，主要是上下文管理和错误处理的开销。
在高并发场景下，errgroup 是适用的，但需要注意以下几点：
- 合理控制并发任务的数量，避免过度并发。
- 对于 CPU 密集型任务，并发数量不宜超过 CPU 核心数。
- 对于 I/O 密集型任务，可以适当增加并发数量。
- 使用工作池模式，复用 Goroutine，减少 Goroutine 创建和销毁的开销。

示例：

对于 1000 个并发任务，errgroup 的性能开销可以忽略不计。
对于 10000 个并发任务，需要考虑系统资源和上下文切换开销。

9. 实战练习

9.1 基础练习：并行下载文件

题目：使用 errgroup 并行下载多个文件，当任何文件下载失败时，取消其他文件的下载。

解题思路：

使用 errgroup 管理多个并发的下载任务。
每个任务负责下载一个文件。
当任何任务失败时，errgroup 会取消其他任务。

常见误区：

忽略上下文取消，导致即使其他任务失败，下载仍继续。
资源泄漏，没有正确关闭文件和网络连接。
错误处理不当，没有正确返回错误。

分步提示：

创建一个带有上下文的 errgroup。
为每个文件创建一个下载任务。
在任务函数中，使用上下文控制下载过程。
使用 defer 语句确保资源被正确关闭。
等待所有任务完成，并处理错误。

参考代码：

package main

import (
    "context"
    "fmt"
    "golang.org/x/sync/errgroup"
    "io"
    "net/http"
    "os"
    "path/filepath"
)

func downloadFile(ctx context.Context, url, filePath string) error {
    req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
    if err != nil {
        return fmt.Errorf("creating request: %w", err)
    }
    
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return fmt.Errorf("sending request: %w", err)
    }
    defer resp.Body.Close()
    
    if resp.StatusCode != http.StatusOK {
        return fmt.Errorf("download failed: status code %d", resp.StatusCode)
    }
    
    // 创建目录
    dir := filepath.Dir(filePath)
    if err := os.MkdirAll(dir, 0755); err != nil {
        return fmt.Errorf("creating directory: %w", err)
    }
    
    // 创建文件
    file, err := os.Create(filePath)
    if err != nil {
        return fmt.Errorf("creating file: %w", err)
    }
    defer file.Close()
    
    // 复制内容
    if _, err := io.Copy(file, resp.Body); err != nil {
        return fmt.Errorf("copying content: %w", err)
    }
    
    fmt.Printf("Downloaded %s to %s\n", url, filePath)
    return nil
}

func main() {
    files := []struct {
        url      string
        filePath string
    }{
        {"https://example.com/file1.txt", "downloads/file1.txt"},
        {"https://example.com/file2.txt", "downloads/file2.txt"},
        {"https://example.com/file3.txt", "downloads/file3.txt"},
    }
    
    g, ctx := errgroup.WithContext(context.Background())
    
    for _, file := range files {
        file := file
        g.Go(func() error {
            return downloadFile(ctx, file.url, file.filePath)
        })
    }
    
    if err := g.Wait(); err != nil {
        fmt.Printf("Download failed: %v\n", err)
    } else {
        fmt.Println("All files downloaded successfully")
    }
}

9.2 进阶练习：并行处理 API 响应

题目：使用 errgroup 并行调用多个 API 接口，处理响应数据，并在任何 API 调用失败时取消其他调用。

解题思路：

使用 errgroup 管理多个并发的 API 调用任务。
每个任务负责调用一个 API 接口并处理响应数据。
当任何任务失败时，errgroup 会取消其他任务。

常见误区：

忽略上下文取消，导致即使其他任务失败，API 调用仍继续。
错误处理不当，没有正确返回错误。
数据竞争，多个任务同时修改共享数据。

分步提示：

创建一个带有上下文的 errgroup。
为每个 API 接口创建一个调用任务。
在任务函数中，使用上下文控制 API 调用过程。
使用互斥锁保护共享数据的访问。
等待所有任务完成，并处理错误。

参考代码：

package main

import (
    "context"
    "encoding/json"
    "fmt"
    "golang.org/x/sync/errgroup"
    "net/http"
    "sync"
)

type User struct {
    ID   int    `json:"id"`
    Name string `json:"name"`
}

type Order struct {
    ID     int `json:"id"`
    UserID int `json:"user_id"`
}

func main() {
    var mu sync.Mutex
    var users []User
    var orders []Order
    
    g, ctx := errgroup.WithContext(context.Background())
    
    // 调用用户 API
    g.Go(func() error {
        req, err := http.NewRequestWithContext(ctx, "GET", "https://api.example.com/users", nil)
        if err != nil {
            return fmt.Errorf("creating user request: %w", err)
        }
        
        client := &http.Client{}
        resp, err := client.Do(req)
        if err != nil {
            return fmt.Errorf("sending user request: %w", err)
        }
        defer resp.Body.Close()
        
        if resp.StatusCode != http.StatusOK {
            return fmt.Errorf("user API failed: status code %d", resp.StatusCode)
        }
        
        var userData []User
        if err := json.NewDecoder(resp.Body).Decode(&userData); err != nil {
            return fmt.Errorf("decoding user data: %w", err)
        }
        
        mu.Lock()
        users = userData
        mu.Unlock()
        
        fmt.Println("Fetched users successfully")
        return nil
    })
    
    // 调用订单 API
    g.Go(func() error {
        req, err := http.NewRequestWithContext(ctx, "GET", "https://api.example.com/orders", nil)
        if err != nil {
            return fmt.Errorf("creating order request: %w", err)
        }
        
        client := &http.Client{}
        resp, err := client.Do(req)
        if err != nil {
            return fmt.Errorf("sending order request: %w", err)
        }
        defer resp.Body.Close()
        
        if resp.StatusCode != http.StatusOK {
            return fmt.Errorf("order API failed: status code %d", resp.StatusCode)
        }
        
        var orderData []Order
        if err := json.NewDecoder(resp.Body).Decode(&orderData); err != nil {
            return fmt.Errorf("decoding order data: %w", err)
        }
        
        mu.Lock()
        orders = orderData
        mu.Unlock()
        
        fmt.Println("Fetched orders successfully")
        return nil
    })
    
    if err := g.Wait(); err != nil {
        fmt.Printf("API call failed: %v\n", err)
    } else {
        fmt.Printf("Fetched %d users and %d orders\n", len(users), len(orders))
        // 处理数据...
    }
}

9.3 挑战练习：分布式任务协调

题目：使用 errgroup 协调多个分布式任务，当任何任务失败时，取消其他任务并执行清理操作。

解题思路：

使用 errgroup 管理多个并发的分布式任务。
每个任务负责执行一个分布式操作。
当任何任务失败时，errgroup 会取消其他任务。
实现清理操作，确保资源被正确释放。

常见误区：

忽略上下文取消，导致即使其他任务失败，操作仍继续。
清理操作不当，导致资源泄漏。
错误处理不当，没有正确返回错误。

分步提示：

创建一个带有上下文的 errgroup。
为每个分布式任务创建一个执行任务。
在任务函数中，使用上下文控制任务执行过程。
实现清理操作，确保资源被正确释放。
等待所有任务完成，并处理错误。

参考代码：

package main

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

type DistributedTask struct {
    ID   string
    Data string
}

func executeTask(ctx context.Context, task DistributedTask) error {
    fmt.Printf("Starting task %s\n", task.ID)
    
    // 模拟任务执行
    select {
    case <-time.After(2 * time.Second):
        // 模拟任务失败
        if task.ID == "task3" {
            return fmt.Errorf("task %s failed", task.ID)
        }
        fmt.Printf("Completed task %s\n", task.ID)
        return nil
    case <-ctx.Done():
        fmt.Printf("Cancelled task %s\n", task.ID)
        return ctx.Err()
    }
}

func cleanup() {
    fmt.Println("Performing cleanup operations")
    // 执行清理操作
    time.Sleep(1 * time.Second)
    fmt.Println("Cleanup completed")
}

func main() {
    tasks := []DistributedTask{
        {ID: "task1", Data: "data1"},
        {ID: "task2", Data: "data2"},
        {ID: "task3", Data: "data3"},
        {ID: "task4", Data: "data4"},
    }
    
    g, ctx := errgroup.WithContext(context.Background())
    
    for _, task := range tasks {
        task := task
        g.Go(func() error {
            return executeTask(ctx, task)
        })
    }
    
    if err := g.Wait(); err != nil {
        fmt.Printf("Distributed task execution failed: %v\n", err)
    } else {
        fmt.Println("All distributed tasks completed successfully")
    }
    
    // 执行清理操作
    cleanup()
}

10. 知识点总结

10.1 核心要点

errgroup 的作用：管理一组并发任务，处理错误传播和上下文取消。
基本用法：
- 使用 errgroup.WithContext 创建一个带有上下文的 errgroup。
- 使用 g.Go 添加并发任务。
- 使用 g.Wait 等待所有任务完成并处理错误。
工作原理：
- 使用 WaitGroup 管理任务执行状态。
- 使用 errOnce 确保只捕获第一个错误。
- 使用上下文取消机制通知其他任务停止执行。
适用场景：
- 并行处理多个相关任务。
- 需要错误传播和上下文取消的场景。
- 分布式系统协调和微服务健康检查等。
错误处理：
- 只返回第一个遇到的错误。
- 当遇到错误时，取消上下文，通知其他任务停止执行。

10.2 易错点回顾

忽略上下文取消：任务函数没有检查上下文是否被取消，导致资源浪费。
错误处理不当：任务函数中的错误没有正确返回，导致 errgroup 无法捕获错误。
任务函数过于复杂：任务函数包含多个职责，导致错误处理困难。
资源泄漏：任务函数中打开的资源没有正确关闭，导致资源泄漏。
上下文传递不当：任务函数没有使用 errgroup 提供的上下文，导致无法收到取消信号。
错误类型处理不当：没有正确处理不同类型的错误，导致错误信息不明确。

11. 拓展参考资料

11.1 官方文档链接

11.2 进阶学习路径建议

并发编程基础：学习 Goroutine、Channel、WaitGroup 等基本概念。
上下文管理：深入学习 context 包的使用，理解上下文的传递和取消机制。
错误处理：学习 Go 语言的错误处理机制，包括错误包装、类型断言等。
分布式系统：学习分布式系统的基本概念和协调机制。
微服务架构：学习微服务的设计原则和最佳实践。
性能优化：学习并发程序的性能优化技术，如工作池、信号量等。

处理错误 errgroup ​

1. 概述 ​

2. 基本概念 ​

2.1 语法 ​

2.1.1 基本用法 ​

2.1.2 示例代码 ​

2.2 语义 ​

2.3 规范 ​

3. 原理深度解析 ​

3.1 errgroup 的原理 ​

3.2 实现机制 ​

3.3 上下文管理 ​

3.4 错误处理策略 ​

3.5 适用场景 ​

4. 常见错误与踩坑点 ​

4.1 忽略上下文取消 ​

4.2 错误处理不当 ​

4.3 任务函数过于复杂 ​

4.4 资源泄漏 ​

4.5 上下文传递不当 ​

4.6 错误类型处理不当 ​

5. 常见应用场景 ​

5.1 并行处理多个 HTTP 请求 ​

5.2 并行处理文件 ​

5.3 并行数据库操作 ​

5.4 并行计算 ​

5.5 并行服务启动 ​

6. 企业级进阶应用场景 ​

6.1 微服务健康检查 ​

6.2 数据ETL处理 ​

6.3 分布式系统协调 ​

6.4 批量 API 调用 ​

6.5 并行测试执行 ​

7. 行业最佳实践 ​

7.1 合理使用上下文 ​

7.2 错误处理规范化 ​

7.3 资源管理 ​

7.4 任务粒度控制 ​

7.5 错误传播策略 ​

7.6 监控和日志 ​

7.7 测试覆盖 ​

7.8 性能优化 ​

8. 常见问题答疑（FAQ） ​

8.1 errgroup 与 WaitGroup 有什么区别？ ​

8.2 如何处理多个错误？ ​

8.3 如何设置任务的超时时间？ ​

8.4 如何限制并发数量？ ​

8.5 如何处理 panic？ ​

8.6 errgroup 的性能如何？ ​

9. 实战练习 ​

9.1 基础练习：并行下载文件 ​

9.2 进阶练习：并行处理 API 响应 ​

9.3 挑战练习：分布式任务协调 ​

10. 知识点总结 ​

10.1 核心要点 ​

10.2 易错点回顾 ​

11. 拓展参考资料 ​

11.1 官方文档链接 ​

11.2 进阶学习路径建议 ​

处理错误 errgroup

1. 概述

2. 基本概念

2.1 语法

2.1.1 基本用法

2.1.2 示例代码

2.2 语义

2.3 规范

3. 原理深度解析

3.1 errgroup 的原理

3.2 实现机制

3.3 上下文管理

3.4 错误处理策略

3.5 适用场景

4. 常见错误与踩坑点

4.1 忽略上下文取消

4.2 错误处理不当

4.3 任务函数过于复杂

4.4 资源泄漏

4.5 上下文传递不当

4.6 错误类型处理不当

5. 常见应用场景

5.1 并行处理多个 HTTP 请求

5.2 并行处理文件

5.3 并行数据库操作

5.4 并行计算

5.5 并行服务启动

6. 企业级进阶应用场景

6.1 微服务健康检查

6.2 数据ETL处理

6.3 分布式系统协调

6.4 批量 API 调用

6.5 并行测试执行

7. 行业最佳实践

7.1 合理使用上下文

7.2 错误处理规范化

7.3 资源管理

7.4 任务粒度控制

7.5 错误传播策略

7.6 监控和日志

7.7 测试覆盖

7.8 性能优化

8. 常见问题答疑（FAQ）

8.1 errgroup 与 WaitGroup 有什么区别？

8.2 如何处理多个错误？

8.3 如何设置任务的超时时间？

8.4 如何限制并发数量？

8.5 如何处理 panic？

8.6 errgroup 的性能如何？

9. 实战练习

9.1 基础练习：并行下载文件

9.2 进阶练习：并行处理 API 响应

9.3 挑战练习：分布式任务协调

10. 知识点总结

10.1 核心要点

10.2 易错点回顾

11. 拓展参考资料

11.1 官方文档链接

11.2 进阶学习路径建议