Go並發程式設計中的錯誤處理與復原策略

並發程式設計中錯誤處理有兩種方法：主動錯誤處理（傳播錯誤）和被動錯誤處理（錯誤管道）。恢復策略有兩種：恢復（捕獲恐慌）和重試（多次執行）。實戰案例展示了這四種方法的使用。

Go並發程式設計中的錯誤處理與復原策略

錯誤處理

在Go並發程式設計中，錯誤處理至關重要。有兩種主要的方法來處理錯誤：

• 主動錯誤處理（主動錯誤傳播）: 這種方法依賴於明確地將錯誤從一個函數傳遞到另一個函數。如果函數遇到錯誤，它將傳回該錯誤，而呼叫函數的函數則需要處理該錯誤。
• 被動錯誤處理（錯誤管道）: 這種方法使用 channels 來傳遞錯誤。函數將錯誤傳送到 channel，而呼叫函數從 channel 接收錯誤。這種方法提供了更大的靈活性，但會增加程式碼複雜度。

恢復策略

除了錯誤處理，並發程式設計中還存在著復原策略。恢復策略是當一個函數因錯誤而無法正常執行時所採取的措施。有兩種常見的恢復策略：

• 恢復（Recovery）: 這種策略透過使用內建的 recover 函數捕獲恐慌並恢復執行。
• 重試 (Retry): 這種策略嘗試多次執行操作，直到成功或達到預先定義的重試次數。

實戰案例

主動錯誤處理

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

以上是Go並發程式設計中的錯誤處理與復原策略的詳細內容。更多資訊請關注PHP中文網其他相關文章！