Quel est le mécanisme de gestion des erreurs de goroutine dans la fonction golang ?

Par défaut, les erreurs dans Goroutines in Go sont ignorées et doivent être traitées explicitement. Les méthodes de traitement sont les suivantes : 1. Utilisez les fonctions de panique et de récupération pour capturer les exceptions ; 2. Utilisez le canal des erreurs pour transmettre les erreurs afin que les erreurs puissent être collectées et traitées dans la fonction principale.

Le mécanisme de gestion des erreurs de Goroutine dans les fonctions du langage Go

Goroutine est la pierre angulaire de la programmation simultanée en langage Go, qui permet aux développeurs d'exécuter plusieurs fonctions en même temps. Bien que les Goroutines soient très puissantes, leurs mécanismes de gestion des erreurs présentent certaines subtilités.

Comportement par défaut : Ignorer les erreurs

Par défaut, lorsqu'une erreur survient dans une Goroutine, l'erreur est ignorée. Cela signifie que les erreurs ne sont pas propagées à la fonction principale et ne sont pas enregistrées. Cela peut entraîner des problèmes difficiles à suivre et à déboguer.

Panique et récupération

Une façon de gérer les erreurs dans Goroutine est d'utiliser les fonctions panique et récupération. panic lève une exception, tandis que recover intercepte l'exception du même Goroutine. panic 和 recover 函数。panic 会引发一个异常，而 recover 则可以从同一 Goroutine 中捕获异常。

示例：

func goroutineWithPanic() {
    defer func() {
        if err := recover(); err != nil {
            log.Println("Error in goroutine:", err)
        }
    }()

    // 正常代码
}

func main() {
    go goroutineWithPanic()
}

在上面的示例中，defer 语句会确保 recover 函数始终被调用，即使在 panic

Exemple :

func goroutineWithErrors(errors chan error) {
    // 正常代码

    // 如果发生错误，发送错误到通道
    if err != nil {
        errors <- err
    }
}

func main() {
    errors := make(chan error)
    go goroutineWithErrors(errors)

    // 从通道中读取错误
    err := <-errors
    if err != nil {
        log.Println("Error from goroutine:", err)
    }
}

Dans l'exemple ci-dessus, l'instruction defer garantira que la fonction recover est toujours appelée, même si le panic la fonction renvoie une exception.

Errors Channel

Une autre façon de gérer les erreurs dans Goroutine est d'utiliser le canal d'erreurs. Le canal des erreurs est un canal sans tampon qui peut être utilisé pour transmettre les erreurs d'une Goroutine.

Exemple :

func main() {
    // 创建一个 errors 通道来收集错误
    errors := make(chan error)

    // 创建一个 goroutine 数组
    routines := []func(){
        func() { sendRequest("https://example1.com", errors) },
        func() { sendRequest("https://example2.com", errors) },
        func() { sendRequest("https://example3.com", errors) },
    }

    // 并行运行 goroutine
    for _, r := range routines {
        go r()
    }

    // 收集和处理 goroutine 中发生的错误
    for i := 0; i < len(routines); i++ {
        if err := <-errors; err != nil {
            log.Println("Error from goroutine:", err)
        }
    }
}

Dans cet exemple, le canal des erreurs est utilisé pour transmettre les erreurs qui se produisent dans Goroutine.

Cas pratique

Considérez le cas pratique suivant d'utilisation de Goroutine pour exécuter des requêtes HTTP en parallèle : 🎜rrreee🎜Dans ce cas pratique, en utilisant le canal des erreurs, nous pouvons garantir que toutes les erreurs survenant dans Goroutine sont collectées et traitées de manière appropriée. 🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!