Pengendalian ralat dan strategi pemulihan dalam pengaturcaraan serentak Go

Terdapat dua kaedah pengendalian ralat dalam pengaturcaraan serentak: pengendalian ralat aktif (penyebaran ralat) dan pengendalian ralat pasif (saluran paip ralat). Terdapat dua strategi pemulihan: pemulihan (tangkap panik) dan cuba semula (berbilang pelaksanaan). Kes praktikal menunjukkan penggunaan empat kaedah ini.

Pengendalian ralat dan strategi pemulihan dalam pengaturcaraan serentak Go

Pengendalian ralat

Dalam pengaturcaraan serentak Go, pengendalian ralat adalah penting. Terdapat dua cara utama untuk mengendalikan ralat:

• Pengendalian Ralat Aktif (Penyebaran Ralat Aktif): Pendekatan ini bergantung pada menghantar ralat secara eksplisit dari satu fungsi ke fungsi yang lain. Jika fungsi menghadapi ralat, ia mengembalikan ralat itu, dan fungsi panggilan perlu mengendalikan ralat itu.
• Pengendalian Ralat Pasif (Ralat Paip): Kaedah ini menggunakan saluran untuk menyampaikan ralat. Fungsi menghantar ralat ke saluran, dan fungsi panggilan menerima ralat daripada saluran. Pendekatan ini memberikan fleksibiliti yang lebih besar tetapi meningkatkan kerumitan kod.

Strategi Pemulihan

Selain pengendalian ralat, terdapat juga strategi pemulihan dalam pengaturcaraan serentak. Strategi pemulihan ialah tindakan yang diambil apabila fungsi gagal dilaksanakan dengan betul disebabkan ralat. Terdapat dua strategi pemulihan biasa:

• Pemulihan: Strategi ini menangkap panik dan menyambung semula pelaksanaan dengan menggunakan fungsi recover terbina dalam.
• Cuba semula: Strategi ini cuba melakukan operasi beberapa kali sehingga ia berjaya atau mencapai bilangan percubaan semula yang telah ditetapkan.

Kes praktikal

Pengendalian ralat aktif

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)
}

Pengendalian ralat pasif

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")
    }
}

Pemulihan

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)
}

Cuba semula

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)
    }
}

Atas ialah kandungan terperinci Pengendalian ralat dan strategi pemulihan dalam pengaturcaraan serentak Go. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!