흔한 Go 동시성 패턴에는 어떤 것들이 있나요?

Question

Accepted Answer

Go의 goroutine과 channel은 흔한 문제를 해결하는 잘 정립된 **동시성 패턴** 모음을 가능하게 합니다 — 작업 분배, 팬아웃/팬인, 파이프라인, 속도 제한. 이 관용적 패턴을 알면 올바르고 효율적인 동시 시스템을 만들 수 있습니다.

## 워커 풀(worker pool) — 제한된 동시성

```go
func workerPool(jobs <-chan int, results chan<- int, numWorkers int) {
    var wg sync.WaitGroup
    for w := 0; w < numWorkers; w++ {     // 고정된 수의 워커
        wg.Add(1)
        go func() {
            defer wg.Done()
            for job := range jobs {        // 각 워커가 channel이 닫힐 때까지 작업을 가져옴
                results <- process(job)
            }
        }()
    }
    wg.Wait()
    close(results)
}
```

**워커 풀**은 공유 작업 channel에서 소비하는 고정된 수의 goroutine을 실행합니다 — 동시성을 제한합니다(예: 10,000개의 DB 연결을 열지 말고 10개의 워커를 사용). 자원 사용을 제어하는 가장 중요한 패턴입니다.

## 팬아웃 / 팬인(fan-out / fan-in)

```text
팬아웃: 작업을 여러 goroutine에 분배(병렬화)
팬인:  여러 goroutine의 결과를 하나의 channel로 병합
```

```go
// 팬인: 여러 channel을 하나로 병합
func merge(channels ...<-chan int) <-chan int {
    out := make(chan int)
    var wg sync.WaitGroup
    for _, ch := range channels {
        wg.Add(1)
        go func(c <-chan int) {
            defer wg.Done()
            for v := range c { out <- v }   // 각 channel의 값을 out으로 전달
        }(ch)
    }
    go func() { wg.Wait(); close(out) }()    // 모든 소스가 비면 out을 닫음
    return out
}
```

## 파이프라인(pipeline) — channel로 연결된 단계

```go
// 각 단계는 goroutine: 입력 channel에서 받아 출력 channel로 보냄
func generate(nums ...int) <-chan int {
    out := make(chan int)
    go func() { for _, n := range nums { out <- n }; close(out) }()
    return out
}
func square(in <-chan int) <-chan int {
    out := make(chan int)
    go func() { for n := range in { out <- n * n }; close(out) }()
    return out
}
// 합성: square(generate(1,2,3)) → 스트리밍 파이프라인
for result := range square(generate(1, 2, 3)) { fmt.Println(result) }
```

**파이프라인**은 channel을 통해 처리 단계를 연결합니다 — 데이터가 흘러가며 각 단계가 동시에 변환합니다.

## 속도 제한(rate limiting)

```go
limiter := time.Tick(200 * time.Millisecond)   // 200ms마다 틱
for req := range requests {
    <-limiter                                    // 진행 전 다음 틱을 기다림
    go handle(req)                                // → 최대 초당 5개 요청
}
```

## context로 취소(횡단 관심사)

```go
select {
case result := <-work:
case <-ctx.Done():    return   // 취소 시 중단 — 누수 방지
}
```

## 왜 중요한가

이 동시성 패턴들은 실제 동시 Go 시스템을 만드는 실무적 도구 모음으로, 원시 goroutine과 channel을 반복되는 문제에 대한 구조적이고 올바른 해법으로 바꿉니다.

**워커 풀**이 특히 중요합니다 — 제한된 자원(데이터베이스 연결, API 속도 제한, 메모리)을 보호하기 위해 동시성을 제한하여, 시스템을 고갈시키는 무제한 goroutine 생성이라는 흔한 실수를 방지합니다. **팬아웃/팬인**은 작업을 병렬화하고 결과를 병합하며; **파이프라인**은 스트리밍 데이터 변환을 깔끔하게 모델링하고; **속도 제한**은 처리량을 제어합니다.

**context 기반 취소**(goroutine 누수 방지)와 결합하면, 이 패턴들은 프로덕션 Go 서비스가 동시성을 안전하고 효율적으로 처리하는 방법입니다.

이것들을 — 특히 무제한 goroutine을 실행하기보다 워커 풀로 동시성을 제한할 줄 아는 것을 — 이해하는 것은 시니어 Go 역량의 특징이자 자주 나오는 고급 면접 주제입니다. 순진한 동시성(무제한 goroutine, 누수, 경쟁)이 프로덕션 실패의 흔한 원인이기 때문입니다.