Stratégies de gestion des erreurs et de récupération dans la programmation simultanée Go

Il existe deux méthodes de gestion des erreurs en programmation simultanée : la gestion active des erreurs (propagation des erreurs) et la gestion passive des erreurs (pipeline d'erreurs). Il existe deux stratégies de récupération : récupération (catch panique) et nouvelle tentative (exécutions multiples). Des cas pratiques démontrent l’utilisation de ces quatre méthodes.

Stratégies de gestion des erreurs et de récupération dans la programmation simultanée Go

Gestion des erreurs

Dans la programmation simultanée Go, la gestion des erreurs est cruciale. Il existe deux manières principales de gérer les erreurs :

• Gestion active des erreurs (propagation active des erreurs) : Cette approche repose sur le passage explicite des erreurs d'une fonction à une autre. Si une fonction rencontre une erreur, elle renvoie cette erreur et la fonction appelante doit gérer l'erreur.
• Gestion passive des erreurs (Error Pipeline) : Cette méthode utilise des canaux pour générer des erreurs. La fonction envoie l'erreur au canal et la fonction appelante reçoit l'erreur du canal. Cette approche offre une plus grande flexibilité mais augmente la complexité du code.

Stratégie de récupération

En plus de la gestion des erreurs, il existe également des stratégies de récupération en programmation simultanée. Les stratégies de récupération sont des actions prises lorsqu'une fonction ne s'exécute pas correctement en raison d'une erreur. Il existe deux stratégies de récupération courantes :

• Récupération : Cette stratégie capte la panique et reprend l'exécution en utilisant la fonction recover intégrée.
• Réessayer : Cette stratégie tente d'effectuer une opération plusieurs fois jusqu'à ce qu'elle réussisse ou atteigne un nombre prédéfini de tentatives.

Cas pratique

Gestion active des erreurs

func CalculateAverage(numbers []int) (float64, error) {
    if len(numbers) == 0 {
        return 0, errors.New("empty slice")
    }

    sum := 0
    for _, number := range numbers {
        sum += number
    }

    return float64(sum) / float64(len(numbers)), nil
}

func main() {
    numbers := []int{1, 2, 3, 4, 5}
    average, err := CalculateAverage(numbers)
    
    if err != nil {
        fmt.Println(err)
        return
    }
    
    fmt.Println(average)
}

Gestion passive des erreurs

type ErrorChannel chan error

func CalculateAverageWithChannel(numbers []int) ErrorChannel {
    ch := make(ErrorChannel)
    
    go func() {
        if len(numbers) == 0 {
            ch <- errors.New("empty slice")
            return
        }
        
        sum := 0
        for _, number := range numbers {
            sum += number
        }
        
        ch <- nil
        close(ch)
    }()
    
    return ch
}

func main() {
    numbers := []int{1, 2, 3, 4, 5}
    ch := CalculateAverageWithChannel(numbers)
    
    for err := range ch {
        if err != nil {
            fmt.Println(err)
            return
        }
        
        fmt.Println("Average calculated successfully")
    }
}

Récupération

func CalculateAverageWithRecovery(numbers []int) float64 {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("Error occurred:", r)
        }
    }()
    
    if len(numbers) == 0 {
        panic("empty slice")
    }
    
    sum := 0
    for _, number := range numbers {
        sum += number
    }
    
    return float64(sum) / float64(len(numbers))
}

func main() {
    numbers := []int{1, 2, 3, 4, 5}
    average := CalculateAverageWithRecovery(numbers)
    fmt.Println(average)
}

Réessayer

func CalculateAverageWithRetry(numbers []int) (float64, error) {
    var err error = errors.New("empty slice")
    maxRetries := 3
    
    for i := 0; i < maxRetries; i++ {
        if len(numbers) == 0 {
            err = errors.New("empty slice")
            continue
        }
        
        sum := 0
        for _, number := range numbers {
            sum += number
        }
        
        return float64(sum) / float64(len(numbers)), nil
    }
    
    return 0, err
}

func main() {
    numbers := []int{1, 2, 3, 4, 5}
    average, err := CalculateAverageWithRetry(numbers)
    
    if err != nil {
        fmt.Println(err)
    } else {
        fmt.Println(average)
    }
}

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!