Go 동시 프로그래밍의 오류 처리 및 복구 전략

동시 프로그래밍에는 두 가지 오류 처리 방법이 있습니다. 즉, 능동적 오류 처리(오류 전파)와 수동적 오류 처리(오류 파이프라인)입니다. 복구 전략에는 복구(패닉 발생)와 재시도(다중 실행)라는 두 가지 복구 전략이 있습니다. 실제 사례에서는 이 네 가지 방법의 사용을 보여줍니다.

Go 동시 프로그래밍의 오류 처리 및 복구 전략

오류 처리

Go 동시 프로그래밍에서는 오류 처리가 중요합니다. 오류를 처리하는 두 가지 주요 방법이 있습니다.

• 활성 오류 처리(활성 오류 전파): 이 접근 방식은 한 함수에서 다른 함수로 오류를 명시적으로 전달하는 데 의존합니다. 함수에 오류가 발생하면 해당 오류를 반환하고 호출 함수는 오류를 처리해야 합니다.
• 수동적 오류 처리(오류 파이프라인): 이 방법은 채널을 사용하여 오류를 전달합니다. 함수는 오류를 채널로 보내고 호출 함수는 채널에서 오류를 수신합니다. 이 접근 방식은 더 큰 유연성을 제공하지만 코드 복잡성을 증가시킵니다.

복구 전략

오류 처리 외에도 동시 프로그래밍에는 복구 전략도 있습니다. 복구 전략은 오류로 인해 기능이 제대로 실행되지 않을 때 취하는 조치입니다. 두 가지 일반적인 복구 전략이 있습니다.

• 복구: 이 전략은 내장된 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")
    }
}

Recovery

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

Retry

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 중국어 웹사이트의 기타 관련 기사를 참조하세요!