Go 函数并发编程最佳实践：处理异常和恐慌

在 Go 中进行函数并发编程时，处理异常和恐慌至关重要。本文将探究最佳实践，以确保应用程序在并发环境中保持稳定和健壮。

处理异常

异常是可预见的错误，可以通过代码显式处理。在 Go 中，异常可以使用 error 类型表示，该类型是内置接口 error 的实现。要处理异常，请遵循以下步骤：

立即学习“go语言免费学习笔记（深入）”；

func myFunc() error {
    // 代码可能会产生异常
    if err := someFunc(); err != nil {
        return err
    }

    // 其余代码
}

处理恐慌

Golang Uber Dig

使用 uber-go/dig 在 Golang 中实现依赖注入——基于反射容器，提供 Provide/Invoke、dig.In/dig.Out 参数与结果对象，支持命名依赖等

下载

恐慌是不可预见的错误，会导致程序立即终止。在 Go 中，恐慌使用 panic 函数引发，可以使用 recover 函数捕获。要处理恐慌，请遵循以下步骤：

func myFunc() {
    defer func() {
        if err := recover(); err != nil {
            // 恐慌处理逻辑
        }
    }()

    // 代码可能会引起恐慌
    panic("some unexpected error")
}

实战案例：并行处理请求

以下代码演示了如何使用并发编程来并行处理请求，同时处理异常和恐慌：

import (
    "errors"
    "net/http"
    "sync"
)

var wg sync.WaitGroup

func main() {
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        wg.Add(1)
        go func() {
            defer wg.Done()

            // 处理请求
            if err := handleReq(w, r); err != nil {
                http.Error(w, "internal server error", http.StatusInternalServerError)
                return
            }

            // 恐慌处理
            defer func() {
                if err := recover(); err != nil {
                    http.Error(w, "internal panic", http.StatusInternalServerError)
                    return
                }
            }()
        }()
    })

    // 等待所有 goroutine 完成
    wg.Wait()
}

func handleReq(w http.ResponseWriter, r *http.Request) error {
    // 模拟异常
    if r.URL.Path == "/error" {
        return errors.New("requested URL")
    }

    // 模拟恐慌
    if r.URL.Path == "/panic" {
        panic("panic occurred")
    }

    w.Write([]byte("successful request"))
    return nil
}

在本示例中：

• handleReq 函数处理请求，可能会出现异常或引发恐慌。
• main 函数中的 goroutine 并发处理请求，使用 defer 和 recover 来捕获和处理异常和恐慌。
• 主 goroutine 通过 wg.Wait() 等待所有请求 goroutine 完成。

采用这些最佳实践，应用程序可以在并发环境中更稳定地处理错误情况。