面试题：Go语言错误处理在高并发场景下的挑战与应对

1. 分析挑战

多个协程同时产生错误：在高并发场景下，多个协程可能同时执行并产生错误。传统的错误处理方式是在每个函数调用处直接处理错误，而在协程中，由于它们是并发执行的，很难在调用点直接捕获到所有协程的错误。
资源竞争导致错误处理混乱：当多个协程同时访问和修改共享资源时，可能会导致数据竞争，进而使错误处理逻辑变得混乱。例如，一个协程可能在另一个协程正在处理错误时修改了错误相关的状态，导致错误处理流程异常。

2. 解决方案

使用sync.WaitGroup和channel收集错误

package main

import (
    "fmt"
    "sync"
)

func worker(id int, wg *sync.WaitGroup, errCh chan error) {
    defer wg.Done()
    // 模拟可能产生错误的操作
    if id == 2 {
        errCh <- fmt.Errorf("worker %d encountered an error", id)
        return
    }
    fmt.Printf("worker %d completed successfully\n", id)
}

func main() {
    var wg sync.WaitGroup
    errCh := make(chan error, 3)

    for i := 1; i <= 3; i++ {
        wg.Add(1)
        go worker(i, &wg, errCh)
    }

    go func() {
        wg.Wait()
        close(errCh)
    }()

    for err := range errCh {
        fmt.Println("Error:", err)
    }
}

在上述代码中：

sync.WaitGroup 用于等待所有协程完成。wg.Add(1) 在启动协程前增加等待组计数器，wg.Done() 在协程结束时减少计数器，wg.Wait() 会阻塞主线程直到所有协程都调用了 wg.Done()。
channel 用于传递错误。每个协程如果遇到错误，就将错误发送到 errCh 中。主线程通过 for... range 循环从 errCh 中接收错误并处理。

使用context.Context处理错误

package main

import (
    "context"
    "fmt"
    "time"
)

func worker(ctx context.Context, id int) error {
    select {
    case <-time.After(1 * time.Second):
        if id == 2 {
            return fmt.Errorf("worker %d encountered an error", id)
        }
        fmt.Printf("worker %d completed successfully\n", id)
        return nil
    case <-ctx.Done():
        return ctx.Err()
    }
}

func main() {
    ctx, cancel := context.WithCancel(context.Background())
    var errs []error

    for i := 1; i <= 3; i++ {
        go func(id int) {
            err := worker(ctx, id)
            if err != nil {
                errs = append(errs, err)
                cancel()
            }
        }(i)
    }

    time.Sleep(2 * time.Second)
    for _, err := range errs {
        fmt.Println("Error:", err)
    }
}

在这个示例中：

context.Context 用于在协程间传递信号，包括取消信号。如果某个协程遇到错误，它可以调用 cancel() 函数，从而取消其他协程的执行。
每个协程通过 select 语句监听 ctx.Done() 通道，一旦接收到取消信号，就立即返回错误。

3. 保证系统的健壮性和性能

健壮性：
- 使用 sync.Mutex 或 sync.RWMutex 来保护共享资源，防止资源竞争。在访问共享资源前加锁，访问结束后解锁。
- 对所有可能的错误进行全面的处理，避免程序因为未处理的错误而崩溃。
- 利用 defer 语句在函数结束时进行资源清理，例如关闭文件、数据库连接等。
性能：
- 合理设置 channel 的缓冲区大小，避免不必要的阻塞。如果缓冲区设置过小，可能会导致协程频繁阻塞等待数据写入或读取；如果缓冲区设置过大，可能会浪费内存。
- 避免在高并发场景下频繁地加锁和解锁，尽量减少锁的粒度，只在访问共享资源的关键代码段加锁。
- 使用高效的数据结构和算法，例如使用 sync.Map 代替普通的 map 来处理高并发读写，因为 sync.Map 针对高并发场景做了优化。

星途面试题库

面试题：Go语言错误处理在高并发场景下的挑战与应对

知识考点

面试题答案

1. 分析挑战

2. 解决方案

使用sync.WaitGroup和channel收集错误

使用context.Context处理错误

3. 保证系统的健壮性和性能