Bei der gleichzeitigen Programmierung gibt es zwei Methoden zur Fehlerbehandlung: aktive Fehlerbehandlung (Fehlerausbreitung) und passive Fehlerbehandlung (Fehlerpipeline). Es gibt zwei Wiederherstellungsstrategien: Wiederherstellung (Panik abfangen) und Wiederholung (mehrere Ausführungen). Praxisbeispiele demonstrieren den Einsatz dieser vier Methoden.
Bei der gleichzeitigen Go-Programmierung ist die Fehlerbehandlung von entscheidender Bedeutung. Es gibt zwei Hauptmethoden zur Fehlerbehandlung:
Neben der Fehlerbehandlung gibt es auch Wiederherstellungsstrategien in der gleichzeitigen Programmierung. Wiederherstellungsstrategien sind Maßnahmen, die ergriffen werden, wenn eine Funktion aufgrund eines Fehlers nicht ordnungsgemäß ausgeführt wird. Es gibt zwei gängige Wiederherstellungsstrategien:
recover
-Funktion fort. 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) }
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") } }
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) }
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) } }
Das obige ist der detaillierte Inhalt vonFehlerbehandlungs- und Wiederherstellungsstrategien in der gleichzeitigen Go-Programmierung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!