Select와
Channel 심화 패턴

1편이 실행 단위, 2편이 통신 수단이었다면 오늘은 그 둘을 엮는 편이다.

ch := make(chan string)

go func() {
    time.Sleep(200 * time.Millisecond) // 느린 작업
    ch <- "result"
}()

select {
case msg := <-ch: // 결과가 먼저 오면 정상 처리
    t.Log("received:", msg)
case <-time.After(50 * time.Millisecond): // 50ms 초과
    t.Log("timeout!")
}
// → timeout!  (작업 200ms > 제한 50ms)

func simulateAPICall(ctx context.Context, d time.Duration) (string, error) {
    ch := make(chan string, 1) // 버퍼 1 — 이유는 아래

    go func() {
        time.Sleep(d)
        ch <- "api response"
    }()

    select {
    case result := <-ch:  // 응답이 먼저 오면
        return result, nil
    case <-ctx.Done(): // 마감 초과 · 상위에서 취소
        return "", ctx.Err() // context.DeadlineExceeded
    }
}

화살표는 데이터가 흐르는 방향이다. worker 셋이 같은 jobs channel에서 경쟁적으로 꺼내 가며, 누가 몇 개를 가져갈지는 정해져 있지 않다 — 빨리 끝낸 worker가 더 많이 가져간다(자연스러운 부하 분산).

jobs, results := make(chan int, 10), make([]chan int, 3)
for i := range results { results[i] = make(chan int, 10) }
var wg sync.WaitGroup
for i := range results {
    wg.Add(1)
    go func() {                   // 셋이 같은 jobs를 공유한다
        defer wg.Done()
        for job := range jobs {   // close될 때까지 계속 꺼낸다
            results[i] <- job * job
        }
        close(results[i])
    }()
}
for i := 1; i <= 9; i++ { jobs <- i }
close(jobs)                        // 없으면 worker가 영원히 대기
wg.Wait()

source마다 goroutine 하나가 붙어 merged로 값을 넘긴다. 소비자는 channel 하나만 신경 쓰면 된다. 대신 도착 순서는 보장되지 않는다 — 순서가 필요하면 fan-in이 아니라 다른 설계를 골라야 한다.

func fanIn(channels ...<-chan string) <-chan string {
    var wg sync.WaitGroup
    merged := make(chan string)
    for _, ch := range channels {
        wg.Add(1)
        go func() {              // source 하나당 goroutine 하나
            defer wg.Done()
            for v := range ch { merged <- v } // close되면 끝
        }()
    }
    go func() {
        wg.Wait()                 // 전부 끝나기를 기다렸다가
        close(merged)            // 그때 merged를 닫는다
    }()
    return merged
}

var a, b = (<-chan int)(ch1), (<-chan int)(ch2) // receive 전용으로 잡아둔다
for a != nil || b != nil {   // 둘 다 nil = 전부 소진
    select {
    case v, ok := <-a:
        if !ok {
            a = nil              // 닫혔다 → 이 case를 끈다
            continue
        }
        results = append(results, v)
    case v, ok := <-b:
        if !ok {
            b = nil
            continue
        }
        results = append(results, v)
    }
}

• select는 준비된 case 하나를 고른다. 여럿이면 무작위 — 작성 순서에 기대지 말 것
• default를 넣는 순간 non-blocking이 된다. 대신 루프에 넣으면 busy-wait
• timeout은 문법이 아니라 또 하나의 case다 — time.After 또는 ctx.Done()
• 취소를 전파해야 하면 context.WithTimeout, 결과 channel에는 버퍼 1
• fan-out은 처리량, fan-in은 병합. close는 보내는 쪽이 하고 시점은 WaitGroup이 정한다
• channel 변수에 nil을 넣으면 그 case가 꺼진다 — 소진된 소스를 끄는 표준 관용구