Go 同時プログラミングにおけるエラー処理と回復戦略

同時プログラミングにおけるエラー処理には、アクティブなエラー処理 (エラー伝播) とパッシブなエラー処理 (エラー パイプライン) の 2 つの方法があります。リカバリ戦略には、リカバリ (パニックのキャッチ) と再試行 (複数の実行) の 2 つがあります。実際の事例では、これら 4 つの方法の使用法を示します。

Go 同時プログラミングにおけるエラー処理と回復戦略

エラー処理

Go 同時プログラミングでは、エラー処理が重要です。エラーを処理するには主に 2 つの方法があります:

• アクティブ エラー処理 (アクティブ エラー伝播): このアプローチは、ある関数から別の関数にエラーを明示的に渡すことに依存します。関数でエラーが発生すると、そのエラーが返され、呼び出し側の関数がエラーを処理する必要があります。
• 受動的エラー処理 (エラー パイプライン): このメソッドは、チャネルを使用してエラーを配信します。関数はエラーをチャネルに送信し、呼び出し側関数はチャネルからエラーを受け取ります。このアプローチでは柔軟性が高まりますが、コードは複雑になります。

回復戦略

エラー処理に加えて、同時プログラミングには回復戦略もあります。回復戦略は、エラーにより関数が適切に実行できなかった場合に実行されるアクションです。一般的な回復戦略は 2 つあります:

• 回復: この戦略は、パニックを捕捉し、組み込みの recover 関数を使用して実行を再開します。
• 再試行: この戦略は、成功するか、事前に定義された再試行回数に達するまで、操作の実行を複数回試行します。

実際のケース

アクティブエラー処理

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 中国語 Web サイトの他の関連記事を参照してください。