Channel
완전 정복

• 1편에서 배운 건 실행 단위까지였다 — 값을 주고받는 방법은 아직 없다
• 공유 변수 + 뮤텍스로도 되지만, 잠그는 순서를 사람이 기억해야 한다
• Go의 답은 CSP — 값을 건네주면 소유권도 함께 넘어간다
• channel은 통신과 동기화를 한 번에 해결한다. 잠글 것이 없다

// 공유 메모리 — 잠금 순서를 사람이 지킨다
mu.Lock()
result = 42
mu.Unlock()

// channel — 건네주면 소유권도 넘어간다
ch := make(chan int)
go func() { ch <- 42 }()
v := <-ch

• make(chan T) — T 타입만 흐른다. 다른 타입은 컴파일 에러
• 두 번째 인자가 버퍼 크기다. 생략하면 0
• 이 숫자 하나가 동기화 성질을 바꾼다 — 0이면 핸드셰이크, 1 이상이면 큐
• zero value는 nil이다. nil channel은 send·receive 모두 영원히 멈춘다

ch := make(chan int)        // unbuffered
ch := make(chan string, 5) // buffered (5칸)

ch := make(chan Result)     // 구조체도 된다
ch := make(chan chan int)   // channel의 channel도

var ch chan int             // nil — 절대 진행되지 않는다

• 화살표가 channel 오른쪽이면 send — ch <- v
• 화살표가 channel 왼쪽이면 receive — v := <-ch
• 값을 안 받아도 된다. <-ch만 쓰면 "올 때까지 기다린다"는 뜻
• 두 값 형태 v, ok := <-ch의 ok는 channel이 살아 있는지를 알려준다

func TestChannelSendReceive(t *testing.T) {
    ch := make(chan int)

    go func() {
        ch <- 42 // send
    }()

    value := <-ch // send될 때까지 blocking
    assert.Equal(t, 42, value)
}

• cap(ch) — 만들 때 정한 버퍼 용량. 끝까지 변하지 않는다
• len(ch) — 지금 버퍼에 쌓여 있는 값의 개수
• unbuffered channel은 언제나 cap 0, len 0
• 모니터링·로그에는 쓸 만하다. 하지만 흐름 제어에 쓰면 안 된다

ch := make(chan string, 5)

assert.Equal(t, 5, cap(ch)) // 용량
assert.Equal(t, 0, len(ch)) // 대기 중인 값

ch <- "a"
ch <- "b"

assert.Equal(t, 5, cap(ch))
assert.Equal(t, 2, len(ch))

• chan<- int — send 전용. 받으려 하면 컴파일 에러
• <-chan int — receive 전용. 보내거나 닫으면 컴파일 에러
• 런타임 비용은 0이다. 순수하게 컴파일 타임 검사
• 주로 함수 파라미터와 반환 타입에 쓴다. 변수 선언에 쓸 일은 드물다

chan int     // 양방향
chan<- int   // send-only — 넣기만
<-chan int   // receive-only — 꺼내기만

func produce(ch chan<- int) { ch <- 1 } // OK
func consume(ch <-chan int) { <-ch }   // OK

func bad(ch <-chan int) { close(ch) } // 컴파일 에러

• 채널을 없애지 않는다. 버퍼에 남은 값은 그대로 다 꺼낼 수 있다
• "값이 다 갔다"가 아니라 "더 안 보낸다"는 뜻이다
• 그래서 보내는 쪽만 닫을 수 있다 — 받는 쪽은 끝을 알 방법이 없다
• 항상 닫아야 하는 건 아니다. range로 받는 쪽이 있을 때 필요하다

ch := make(chan int, 2)
ch <- 1
ch <- 2
close(ch) // 더 보내지 않겠다

fmt.Println(<-ch) // 1 — 남은 값은 그대로
fmt.Println(<-ch) // 2
fmt.Println(<-ch) // 0 — 다 비었다

• for v := range ch — 값이 올 때까지 기다렸다가 하나씩 꺼낸다
• 끝나는 경우는 딱 하나, channel이 닫히는 것. 개수를 세지 않는다
• close를 잊으면 영원히 blocking된다 — goroutine leak의 단골 원인
• v, ok := <-ch를 직접 쓰는 것과 같지만 ok 검사를 대신해준다

ch := make(chan int, 5)
go func() {
    for i := 1; i <= 5; i++ {
        ch <- i
    }
    close(ch) // 없으면 range가 끝나지 않는다
}()

for v := range ch { // 1 2 3 4 5
    out = append(out, v)
}

• struct{}는 필드가 없어 0바이트다 — 값을 담지 않겠다는 의도가 타입에 드러난다
• chan bool을 쓰면 "true는 뭐고 false는 뭐지?"라는 질문이 따라온다
• 신호는 쌓일 이유가 없으니 보통 unbuffered로 만든다
• 이름은 관례적으로 done, quit, ready

done := make(chan struct{})

go func() {
    // 작업 수행...
    close(done) // 완료 신호
}()

<-done // 완료될 때까지 대기