DocsPricingBlog
Contact Us
Log inSign up for FREE
Back to Tech Articles

Go에서 고루틴 간의 통신 파이프라인: 채널

Sep 07, 2025
# Go

Lukas Schneider

DevOps Engineer · Leapcell

This post is also available in English, 日本語, and Deutsch
Cover of "Go에서 고루틴 간의 통신 파이프라인: 채널"

Go의 동시성 모델은 고루틴과 채널을 중심으로 구축됩니다. 고루틴은 실행의 경량 스레드인 반면, 채널은 통신을 위한 도관입니다. 이 글에서는 Go의 채널을 탐구하여 동시성 애플리케이션 구축에 있어 채널의 강력함과 우아함을 보여줍니다.

통신의 필요성

동시성 프로그래밍에서 독립적인 실행 단위는 종종 정보를 공유하거나 작업을 동기화해야 합니다. 적절한 메커니즘 없이는 경쟁 조건, 교착 상태 및 데이터 손상과 같은 악명 높은 문제로 이어질 수 있습니다. Go는 "메모리를 공유하여 통신하지 마십시오. 대신 통신하여 메모리를 공유하십시오."라는 철학으로 이러한 과제에 정면으로 대처합니다. 이 원칙은 채널에 구현되어 있습니다.

채널이란?

채널은 채널 연산자 <-를 사용하여 값을 송수신할 수 있는 형식화된 도관입니다. 채널의 형식은 채널이 전달하는 값의 형식으로 정의됩니다.

기본 선언부터 시작하겠습니다.

// string 값을 전달하는 채널 선언
var messageChannel chan string

// make를 사용하여 채널 선언 및 초기화
messageChannel := make(chan string)

채널은 참조 타입이므로 함수에 전달할 때 참조로 전달되어 여러 고루틴이 동일한 통신 파이프라인에 대한 액세스를 공유할 수 있습니다.

값 송수신

<- 연산자는 송신 및 수신 모두에 사용됩니다.

  • 송신: channel <- value
  • 수신: variable := <- channel 또는 <- channel(값을 필요로 하지 않는 경우)

하나의 고루틴이 메시지를 보내고 다른 고루틴이 메시지를 받는 간단한 예제를 살펴봅시다.

package main

import (
	"fmt"
	"time"
)

func greeter(messages chan string) {
	msg := "Hello from greeter!"
	fmt.Println("Greeter: Sending message:", msg)
	messages <- msg // 채널에 메시지 보내기
}

func main() {
	// 문자열을 전달하는 채널 생성
	messages := make(chan string)

	// greeter 고루틴 시작
	go greeter(messages)

	// 채널에서 메시지 수신
	receivedMsg := <-messages
	fmt.Println("Main: Received message:", receivedMsg)

	// 고루틴이 완료될 시간을 제공합니다 (이 경우 엄격하게 필요하지는 않음).
	time.Sleep(100 * time.Millisecond)
}

출력:

Greeter: Sending message: Hello from greeter!
Main: Received message: Hello from greeter!

블로킹 동작: 동기화의 힘

기본적으로 채널은 버퍼링되지 않습니다. 버퍼링되지 않은 채널은 송신 작업이 해당 수신 작업이 수행될 때까지 차단되고 그 반대도 마찬가지라는 것을 보장합니다. 이 내재된 차단 동작은 명시적 잠금이나 뮤텍스 없이 동기화하는 데 중요합니다.

이전 예제에서:

  1. greeter 고루틴: messages <- msg는 main 고루틴이 수신할 준비가 될 때까지 차단됩니다.
  2. main 고루틴: receivedMsg := <-messages는 greeter 고루틴이 메시지를 보낼 때까지 차단됩니다.

이를 통해 고루틴 간의 적절한 핸드셰이킹이 보장되고 데이터 경합이 방지되며 메시지가 전송된 후에만 소비된다는 것을 보장합니다.

버퍼링된 채널

버퍼링되지 않은 채널은 엄격한 동기화에 탁월하지만, 때로는 직접적인 수신 없이 제한된 수의 값을 채널에 보낼 수 있도록 하고 싶을 것입니다. 이는 큐와 유사합니다. 이것이 버퍼링된 채널이 사용되는 곳입니다.

make 함수에 용량을 제공하여 버퍼링된 채널을 선언합니다.

// 용량 2개의 버퍼링된 채널 생성
bufferedChannel := make(chan int, 2)

버퍼링된 채널을 사용하면:

  • 송신 작업은 버퍼가 가득 찬 경우에만 차단됩니다.
  • 수신 작업은 버퍼가 비어 있는 경우에만 차단됩니다.

예제로 설명해 드리겠습니다.

package main

import (
	"fmt"
	"time"
)

func sender(ch chan string) {
	fmt.Println("Sender: Sending 'one'")
	ch <- "one" // 버퍼에 공간이 있으면 즉시 차단되지 않음
	fmt.Println("Sender: Sending 'two'")
	ch <- "two" // 버퍼에 공간이 있으면 즉시 차단되지 않음
	fmt.Println("Sender: Sending 'three' (will block if buffer full)")
	ch <- "three" // 용량이 2이고 'one'/'two'가 아직 버퍼에 있으면 차단됨
	fmt.Println("Sender: Sent 'three'") // 이 줄은 'two'가 최소한 수신된 후에만 인쇄됨
}

func main() {
	// 용량 2개의 버퍼링된 채널 생성
	messages := make(chan string, 2)

	go sender(messages)

	// 송신자가 버퍼를 채울 시간을 줍니다.
	time.Sleep(100 * time.Millisecond)

	fmt.Println("Main: Receiving 'one'")
	msg1 := <-messages
	fmt.Println("Main: Received:", msg1)

	fmt.Println("Main: Receiving 'two'")
	msg2 := <-messages
	fmt.Println("Main: Received:", msg2)

	fmt.Println("Main: Receiving 'three'")
	msg3 := <-messages
	fmt.Println("Main: Received:", msg3)

	fmt.Println("Main: Done.")
}

가능한 출력 (정확한 타이밍이 약간 다를 수 있지만 시퀀스는 유지됩니다):

Sender: Sending 'one'
Sender: Sending 'two'
Sender: Sending 'three' (will block if buffer full)
Main: Receiving 'one'
Main: Received: one
Main: Receiving 'two'
Main: Received: two
Sender: Sent 'three'
Main: Receiving 'three'
Main: Received: three
Main: Done.

"Sender: Sent 'three'"가 "Main: Received: two" 후에 인쇄되는 것을 알 수 있습니다. 이는 해당 시점에 버퍼가 "three"를 위한 공간을 확보했기 때문입니다.

버퍼링된 채널은 작업 큐와 같은 시나리오에 유용하며, 프로듀서는 버퍼 제한까지 각 항목을 즉시 처리하기 위해 기다리지 않고 항목을 계속 푸시할 수 있습니다.

채널 방향

채널은 또한 방향을 가질 수 있으며, 송신 전용인지 수신 전용인지를 지정합니다. 이는 컴파일 타임 안전성과 더 나은 의도 문서를 제공합니다.

  • 송신 전용 채널: chan<- string (값을 보낼 수만 있음)
  • 수신 전용 채널: <-chan string (값만 수신할 수 있음)
  • 양방향 채널: chan string (송신 및 수신 모두 가능)
package main

import (
	"fmt"
)

// 이 함수는 채널에만 메시지를 보낼 수 있습니다
func producer(ch chan<- string) {
	ch <- "work item"
}

// 이 함수는 채널에서만 메시지를 수신할 수 있습니다
func consumer(ch <-chan string) {
	msg := <-ch
	fmt.Println("Consumer received:", msg)
}

func main() {
	// 양방향 채널이 생성됩니다
	dataChannel := make(chan string)

	go producer(dataChannel) // producer는 송신 전용 채널을 기대하지만 양방향 채널로 작동합니다
	go consumer(dataChannel) // consumer는 수신 전용 채널을 기대하지만 양방향 채널로 작동합니다

	// 고루틴이 완료될 때까지 기다립니다 (예: sync.WaitGroup 또는 간단한 수신을 사용하여 완료를 보장).
	// 이 간단한 예제에서는 최종 수신을 main에 추가하여 완료를 보장할 수 있습니다.
	// 또는 WaitGroup과 같은 것을 사용할 수 있습니다.
	// 완료를 알리기 위해 다른 채널을 만듭니다.
	done := make(chan bool)
	go func() {
		producer(dataChannel)
		consumer(dataChannel) // 송신된 메시지를 수신합니다
		done <- true
	}()

	<-done
}

main 내에서는 dataChannel이 양방향이지만, producer 또는 consumer에 전달될 때 해당 송신 전용 또는 수신 전용 채널로 암묵적으로 형 변환됩니다. 이는 함수 서명이 통신 패턴을 강제하는 일반적인 패턴입니다.

채널 닫기

송신자는 더 이상 값을 보내지 않음을 나타내기 위해 채널을 닫을 수 있습니다. 수신자는 채널에서 수신을 시도할 때 채널이 닫혔는지 확인할 수 있습니다.

close() 내장 함수가 사용됩니다.

close(myChannel)

range 루프를 사용하여 채널을 반복할 때, 채널이 닫히고 모든 값이 수신되면 루프가 자동으로 종료됩니다.

package main

import (
	"fmt"
)

func generator(ch chan int) {
	for i := 0; i < 5; i++ {
		ch <- i
	}
	close(ch) // 모든 값을 보낸 후 채널 닫기
	fmt.Println("Generator: Channel closed.")
}

func main() {
	numbers := make(chan int)

	go generator(numbers)

	// 채널이 닫힐 때까지 값을 수신하기 위해 채널을 범위로 지정합니다.
	for num := range numbers {
		fmt.Println("Main: Received:", num)
	}

	fmt.Println("Main: All numbers received and channel is closed.")
}

출력:

Main: Received: 0
Main: Received: 1
Main: Received: 2
Main: Received: 3
Main: Received: 4
Generator: Channel closed.
Main: All numbers received and channel is closed.

닫힌 채널에 보내려고 하면 패닉이 발생합니다. 보류 중인 값이 없는 닫힌 채널에서 수신하면 즉시 채널의 값 형식에 대한 제로 값이 반환됩니다.

수신할 때 두 개의 값 할당을 사용하여 채널이 닫혔는지 (또는 비어 있는지) 확인할 수 있습니다.

val, ok := <-myChannel
if !ok {
    fmt.Println("Channel is closed and no more values are available.")
}

Select 문: 여러 채널 관리

Go의 select 문은 여러 채널 작업에서 동시에 통신을 처리하는 데 강력합니다. 이를 통해 고루틴은 여러 통신 작업에서 대기할 수 있습니다. 케이스 중 하나가 진행될 때까지 차단되며, 그런 다음 해당 케이스를 실행합니다. 여러 케이스가 준비되면 의사 무작위로 하나를 선택합니다.

package main

import (
	"fmt"
	"time"
)

func main() {
	c1 := make(chan string)
	c2 := make(chan string)

	go func() {
		time.Sleep(1 * time.Second)
		c1 <- "one"
	}()

	go func() {
		time.Sleep(2 * time.Second)
		c2 <- "two"
	}()

	for i := 0; i < 2; i++ {
		select {
		case msg1 := <-c1:
			fmt.Println("Received from c1:", msg1)
		case msg2 := <-c2:
			fmt.Println("Received from c2:", msg2)
		case <-time.After(3 * time.Second): // 선택 사항: 타임 아웃 케이스
			fmt.Println("Timeout or operations took too long.")
			return
		}
	}
}

출력:

Received from c1: one
Received from c2: two

select 문에는 default 케이스도 비차단 방식으로 제공됩니다.

select {
case msg := <-messages:
    fmt.Println("Received message:", msg)
default:
    fmt.Println("No message received, doing something else...")
}

이 default 케이스는 다른 case가 진행될 수 없으면 즉시 실행됩니다. 비차단 송신 또는 수신을 구현하는 데 유용합니다.

실제 사용 사례

채널은 이론적인 예제뿐만 아니라 Go에서 강력한 동시성 애플리케이션을 구축하는 데 기본적입니다.

  1. 작업자 풀: 채널은 작업자 고루틴 풀에 작업을 분배하고 결과를 수집할 수 있습니다.
  2. 파이프라인: 데이터는 일련의 고루틴을 통해 흐를 수 있으며, 각 단계는 채널을 통해 데이터를 처리하고 다음 단계로 전달합니다.
  3. 취소 신호: done 채널을 사용하여 여러 고루틴에 작업 중지 신호를 보낼 수 있습니다.
  4. 타임아웃 및 마감 시간: time.After와 함께 select를 사용하면 작업에 대한 타임아웃을 설정할 수 있습니다.
  5. 이벤트 알림: 고루틴은 전용 채널에서 게시된 이벤트를 수신 대기할 수 있습니다.
  6. 동시성 원시 타입: 채널은 내부적으로 다른 많은 Go 동시성 기능과 표준 라이브러리 구성 요소를 지원합니다.

결론

채널은 Go의 동시성 모델의 초석이며, 고루틴이 통신하고 동기화하는 안전하고 관용적이며 강력한 방법을 제공합니다. "통신하여 메모리를 공유하라"는 원칙을 채택함으로써 Go 채널은 기존 스레드 기반 동시성의 복잡성을 추상화하여 더 읽기 쉽고 강력하며 성능이 뛰어난 동시성 프로그램을 만들 수 있습니다. 채널을 이해하고 효과적으로 사용하는 것은 Go 동시성을 마스터하는 데 중요합니다.

Share this article

HackerNews

More Posts from Leapcell

Popular Posts