Go의 파이프라인 동시성 패턴: 종합적인 시각적 가이드

⚠️ 이 시리즈는 어떻게 진행되나요?

1. 모든 예제 실행: 코드만 읽지 마세요. 이를 입력하고 실행한 후 동작을 관찰하세요.
2. 실험 및 깨기: 절전 모드를 제거하고 어떤 일이 일어나는지 확인하고, 채널 버퍼 크기를 변경하고, 고루틴 수를 수정합니다.
깨뜨리는 일을 통해 작동 방식을 배울 수 있습니다
3. 동작에 대한 이유: 수정된 코드를 실행하기 전에 결과를 예측해 보세요. 예상치 못한 동작이 보이면 잠시 멈춰서 그 이유를 생각해 보세요. 설명에 도전해보세요.
4. 정신 모델 구축: 각 시각화는 개념을 나타냅니다. 수정된 코드에 대해 자신만의 다이어그램을 그려보세요.

이전 게시물에서는 Go의 다른 동시성 패턴의 구성 요소인 Generator 동시성 패턴을 살펴봤습니다. 여기에서 읽어보실 수 있습니다:

Go의 생성기 동시성 패턴: 시각적 가이드

Souvik Kar Mahapatra ・ 12월 25일

#가다 #지도 시간 #프로그램 작성 #학습

이제 이러한 기본 요소가 어떻게 결합되어 실제 문제를 해결하는 강력한 패턴을 형성하는지 살펴보겠습니다.

이번 게시물에서는 파이프라인 패턴을 다루고 이를 시각화해 보겠습니다. 그럼 우리가 직접 프로세스를 진행해 보도록 하겠습니다.

파이프라인 패턴

파이프라인은 각 단계가 데이터에 대해 특정 작업을 수행하고 결과를 다음 단계로 전달하는 공장의 조립 라인과 같습니다.

우리는 고루틴을 채널과 연결하여 파이프라인을 구축합니다. 여기서 각 고루틴은 데이터를 수신하고 처리하고 다음 단계로 보내는 단계를 나타냅니다.

다음과 같은 간단한 파이프라인을 구현해 보겠습니다.

1. 숫자 생성
2. 제곱합니다
3. 결과 인쇄

// Stage 1: Generate numbers
func generate(nums ...int) <-chan int {
    out := make(chan int)
    go func() {
        defer close(out)
        for _, n := range nums {
            out <- n
        }
    }()
    return out
}

// Stage 2: Square numbers
func square(in <-chan int) <-chan int {
    out := make(chan int)
    go func() {
        defer close(out)
        for n := range in {
            out <- n * n
        }
    }()
    return out
}

// Stage 3: Print numbers
func print(in <-chan int) {
    for n := range in {
        fmt.Printf("%d ", n)
    }
    fmt.Println()
}

func main() {
    // Connect the pipeline
    numbers := generate(2, 3, 4)    // Stage 1
    squares := square(numbers)       // Stage 2
    print(squares)                   // Stage 3
}

✏️ 퀵바이트

<-chan int는 수신 전용 채널을 나타냅니다.
<-chan int 유형의 채널은 값을 보내는 데에만 사용할 수 있고 값을 보내는 데에는 사용할 수 없습니다. 이는 보다 엄격한 통신 패턴을 적용하고 수신자가 실수로 채널에 쓰는 것을 방지하는 데 유용합니다.

chan int 양방향 채널을 나타냅니다.
chan int 유형의 채널을 사용하여 값을 보내고 받을 수 있습니다.

위의 예를 시각화해 보겠습니다.

여기서 파이프라인의 각 빌딩 블록이 생성기 패턴을 따르는 고루틴임을 볼 수 있습니다. 순차 처리와 달리 어떤 단계에서든 데이터가 준비되자마자 파이프라인의 다음 단계에서 데이터 처리를 시작할 수 있음을 의미합니다.

파이프라인의 오류 처리

핵심 원칙은 다음과 같습니다.

1. 각 단계에서는 좋은 가치와 나쁜 가치를 어떻게 해야 할지 정확히 알고 있습니다
2. 오류는 파이프라인에서 사라질 수 없습니다
3. 잘못된 값은 패닉을 일으키지 않습니다
4. 오류 메시지에는 무엇이 잘못되었는지에 대한 맥락이 전달됩니다
5. 파이프라인은 더 많은 단계로 확장될 수 있으며 모두 일관되게 오류를 처리합니다

적절한 오류 처리로 코드를 업데이트해 보겠습니다.

type Result struct {
    Value int
    Err   error
}

func generateWithError(nums ...int) <-chan Result {
    out := make(chan Result)
    go func() {
        defer close(out)
        for _, n := range nums {
            if n < 0 {
                out <- Result{Err: fmt.Errorf("negative number: %d", n)}
                return
            }
            out <- Result{Value: n}
        }
    }()
    return out
}

func squareWithError(in <-chan Result) <-chan Result {
    out := make(chan Result)
    go func() {
        defer close(out)
        for r := range in {
            if r.Err != nil {
                out <- r  // Forward the error
                continue
            }
            out <- Result{Value: r.Value * r.Value}
        }
    }()
    return out
}

func main() {
    // Using pipeline with error handling
    for result := range squareWithError(generateWithError(2, -3, 4)) {
        if result.Err != nil {
            fmt.Printf("Error: %v\n", result.Err)
            continue
        }
        fmt.Printf("Result: %d\n", result.Value)
    }
}

파이프라인 패턴을 사용하는 이유는 무엇입니까?

더 잘 이해하기 위해 예를 들어 보겠습니다. 아래 표시된 파이프라인 패턴을 따르는 데이터 처리 워크플로가 있습니다.

1. 파이프라인의 각 단계는 독립적으로 작동하며 채널을 통해서만 통신합니다. 이를 통해 다음과 같은 여러 가지 이점을 얻을 수 있습니다.

? 각 단계는 독립적으로 개발, 테스트 및 수정이 가능합니다
? 한 스테이지의 내부를 변경해도 다른 스테이지에는 영향을 주지 않습니다
? 새로운 스테이지를 추가하거나 기존 스테이지를 수정하기 쉽습니다
? 명확한 관심사 분리

1. 파이프라인 패턴은 자연스럽게 병렬/동시 처리를 가능하게 합니다. 각 단계에서는 데이터가 제공되는 즉시 서로 다른 데이터를 동시에 처리할 수 있습니다.

그리고 가장 좋은 점은 무엇인가요? 다음과 같이 더 많은 동시 요구 사항을 위해 각 단계(작업자)의 여러 인스턴스를 실행할 수 있습니다.

?? 그런데 그게 팬인과 팬아웃 동시 패턴 아닌가요?

빙고! 바로 거기에서 잘 잡혔습니다. 실제로는 Fan-Out, Fan-In 패턴으로 파이프라인 패턴의 특정 유형입니다. 다음 게시물에서 자세히 다룰 예정이니 너무 걱정하지 마세요 ;)

실제 사용 사례

파이프라인에서 이미지 처리

// Stage 1: Generate numbers
func generate(nums ...int) <-chan int {
    out := make(chan int)
    go func() {
        defer close(out)
        for _, n := range nums {
            out <- n
        }
    }()
    return out
}

// Stage 2: Square numbers
func square(in <-chan int) <-chan int {
    out := make(chan int)
    go func() {
        defer close(out)
        for n := range in {
            out <- n * n
        }
    }()
    return out
}

// Stage 3: Print numbers
func print(in <-chan int) {
    for n := range in {
        fmt.Printf("%d ", n)
    }
    fmt.Println()
}

func main() {
    // Connect the pipeline
    numbers := generate(2, 3, 4)    // Stage 1
    squares := square(numbers)       // Stage 2
    print(squares)                   // Stage 3
}

또는 로그 처리 파이프라인만큼 복잡한 것

파이프라인 확장 패턴

수평 확장(팬아웃, 팬인)

이 패턴은 작업을 독립적으로 처리할 수 있는 CPU 바인딩 작업에 이상적입니다. 파이프라인은 여러 작업자에게 작업을 배포한 다음 결과를 재결합합니다. 이는 다음과 같은 경우에 특히 효과적입니다.

1. CPU를 많이 사용하는 처리(데이터 변환, 계산)
2. 작업을 독립적으로 처리할 수 있습니다
3. 여러 개의 CPU 코어를 사용할 수 있습니다

버퍼 파이프라인

이 패턴은 파이프라인 단계 간의 속도 불일치를 관리하는 데 도움이 됩니다. 버퍼는 충격 흡수 장치 역할을 하여 빠른 스테이지가 느린 스테이지에 의해 방해받지 않고 앞으로 작업할 수 있도록 합니다. 다음과 같은 경우에 유용합니다.

1. 단계마다 처리 속도가 다릅니다
2. 꾸준한 처리량을 유지하고 싶은 경우
3. 버퍼링을 위한 메모리 사용량은 허용됩니다
4. 폭발 처리를 처리해야 합니다

일괄 처리

이 패턴은 여러 항목을 단일 배치로 그룹화하여 I/O 바인딩 작업을 최적화합니다. 한 번에 하나씩 항목을 처리하는 대신 그룹으로 모아서 함께 처리합니다. 다음과 같은 경우에 효과적입니다.

1. 외부 시스템(데이터베이스, API)으로 작업하고 있습니다
2. 네트워크 왕복 비용이 많이 듭니다
3. 요청당 상당한 고정 오버헤드가 있는 작업
4. 지연 시간에 비해 처리량을 최적화해야 합니다

이러한 각 패턴은 필요에 따라 결합될 수 있습니다. 예를 들어, 여러 작업자가 각각 항목의 배치를 처리하는 수평 확장을 통한 일괄 처리를 사용할 수 있습니다. 핵심은 병목 현상을 이해하고 이를 해결하기 위한 적절한 패턴을 선택하는 것입니다.

---

이제 제너레이터 패턴에 대한 심층 분석을 마무리합니다! 다음에는 파이프라인 동시성 패턴을 살펴보고 생성기를 서로 연결하여 강력한 데이터 처리 흐름을 구축하는 방법을 살펴보겠습니다.

이 게시물이 도움이 되었거나 질문이 있거나 생성기에 대한 자신의 경험을 공유하고 싶다면 아래 댓글을 통해 여러분의 의견을 듣고 싶습니다. 귀하의 통찰력과 질문은 모든 사람에게 더 나은 설명을 제공하는 데 도움이 됩니다.

Golang의 고루틴과 채널에 대한 시각적 가이드를 놓쳤다면 여기에서 확인하세요.

Golang의 고루틴과 채널 이해 및 시각화

Souvik Kar Mahapatra ・ 12월 20일

#가다 #프로그램 작성 #학습 #지도 시간

더 많은 Go 동시성 패턴을 기대해 주세요! ?

위 내용은 Go의 파이프라인 동시성 패턴: 종합적인 시각적 가이드의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!