通过通道传递错误是Go中处理goroutine错误的核心方法，结合WaitGroup、Context和recover可实现完整的错误管理。使用带缓冲通道避免阻塞，主协程接收并处理错误；多个goroutine时用WaitGroup同步，并通过关闭通道通知结束；利用Context在错误发生时取消其他任务，防止资源浪费；在defer中使用recover捕获panic并转为error返回，避免程序崩溃。关键是要确保所有错误都被显式处理，不被忽略。

在Go语言中，goroutine是实现并发的核心机制。但由于其轻量级和异步执行的特性，goroutine内部发生的错误无法直接被外部捕获，如果不妥善处理，会导致程序出现不可预料的行为或静默失败。本文将详细介绍如何在Golang中有效捕获和处理goroutine中的错误。

使用通道（Channel）传递错误

最常见且推荐的方式是通过通道将错误从goroutine中传回主协程。这种方式保持了并发安全，也符合Go“通过通信共享内存”的设计哲学。

定义一个接收错误的通道，让goroutine在执行完毕或出错时发送错误信息。

package main
import (
"fmt"
"time"
)
func doWork() error {
// 模拟可能出错的任务
time.Sleep(1 * time.Second)
return fmt.Errorf("something went wrong")
}
func worker(resultChan chan<- error) {
err := doWork()
resultChan <- err // 发送错误到通道
}
func main() {
errChan := make(chan error, 1) // 带缓冲通道避免goroutine阻塞
go worker(errChan)

// 主协程等待结果
if err := <-errChan; err != nil {
    fmt.Printf("worker returned error: %v\n", err)
}

}

关键点： 使用带缓冲的通道可以防止goroutine因无法发送错误而永久阻塞，尤其是在主流程提前退出的情况下。
利用WaitGroup与Error Channel结合
当需要启动多个goroutine并收集它们的错误时，可以结合sync.WaitGroup和错误通道来统一管理。
每个goroutine完成任务后通知WaitGroup，并将错误发送到公共的错误通道。
示例代码：
package main
import (
"fmt"
"sync"
)
func task(id int, wg *sync.WaitGroup, errCh chan<- error) {
defer wg.Done()
if id == 2 {
    errCh <- fmt.Errorf("task %d failed", id)
    return
}

errCh <- nil // 成功也发送nil，确保通道不会阻塞

}
func main() {
var wg sync.WaitGroup
errCh := make(chan error, 3) // 缓冲大小等于goroutine数量
for i := 1; i <= 3; i++ {
    wg.Add(1)
    go task(i, &wg, errCh)
}

go func() {
    wg.Wait()
    close(errCh) // 所有任务完成，关闭通道
}()

// 收集所有错误
for err := range errCh {
    if err != nil {
        fmt.Printf("error caught: %v\n", err)
    }
}
}

注意： 错误通道必须关闭，否则range会一直等待。同时建议为每个结果发送error（包括nil），以保证数据一致性。
通过Context控制goroutine生命周期与错误传播
实际项目中，常需在发生错误时取消其他正在运行的goroutine。此时可结合context.Context实现错误通知与提前终止。
一旦某个任务出错，通过cancel函数通知其他goroutine退出，避免资源浪费。
示例代码：
package main
import (
"context"
"fmt"
"time"
)
func riskyTask(ctx context.Context, id int, errCh chan<- error) {
select {
case <-time.After(2 * time.Second):
if id == 1 {
errCh <- fmt.Errorf("task %d timed out or failed", id)
} else {
errCh <- nil
}
case <-ctx.Done():
errCh <- ctx.Err() // 被取消时返回上下文错误
return
}
}
func main() {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
errCh := make(chan error, 3)

for i := 1; i <= 3; i++ {
    go riskyTask(ctx, i, errCh)
}

// 模拟某任务出错，触发取消
time.Sleep(1 * time.Second)
cancel() // 触发所有监听ctx.Done()的goroutine退出

// 收集错误
for i := 0; i < 3; i++ {
    if err := <-errCh; err != nil {
        fmt.Printf("received error: %v\n", err)
    }
}

}

优势： 利用context能实现跨goroutine的错误响应和资源清理，适合长时间运行的服务。
避免panic导致程序崩溃
goroutine中未被捕获的panic会终止该协程，并可能导致主程序崩溃。应使用recover在defer中捕获panic并转为error返回。
尤其在库函数或服务中，不应让panic逃逸到调用方。
示例代码：
func safeWorker(errCh chan<- error) {
    defer func() {
        if r := recover(); r != nil {
            var err error
            switch e := r.(type) {
            case string:
                err = fmt.Errorf("panic: %s", e)
            case error:
                err = fmt.Errorf("panic: %v", e)
            default:
                err = fmt.Errorf("unknown panic")
            }
            errCh <- err
        }
    }()
// 可能引发panic的操作
panic("oops")

}

提示： recover只能在defer中生效。捕获后可根据业务决定是否继续传播错误。
基本上就这些。合理使用通道传递错误、配合WaitGroup和Context管理生命周期，再辅以recover防止panic扩散，就能构建出健壮的并发程序。关键是不要让错误在goroutine里“消失”。