Go 동시성 심층 가이드 — 고루틴·채널·컨텍스트, 제대로 쓰는 법

고루틴 기본 사용
package main

import (
	"fmt"
	"sync"
)

func printMessage(msg string, wg *sync.WaitGroup) {
	defer wg.Done() // 함수 종료 시 WaitGroup 카운터 감소
	fmt.Println(msg)
}

func main() {
	var wg sync.WaitGroup

	for i := 0; i < 5; i++ {
		wg.Add(1) // 고루틴 시작 전 카운터 증가
		go printMessage(fmt.Sprintf("고루틴 %d 실행", i), &wg)
	}

	wg.Wait() // 모든 고루틴이 Done()을 호출할 때까지 대기
	fmt.Println("모든 고루틴 완료")
}

언버퍼드·버퍼드 채널 비교
package main

import "fmt"

func sum(s []int, c chan int) {
	total := 0
	for _, v := range s {
		total += v
	}
	c <- total // 결과를 채널로 전송
}

func main() {
	s := []int{7, 2, 8, -9, 4, 0}

	// 언버퍼드 채널: 수신자가 받을 때까지 송신자 블록
	c := make(chan int)
	go sum(s[:len(s)/2], c) // [-9, 4, 0] 합계 → -5
	go sum(s[len(s)/2:], c) // [7, 2, 8] 합계 → 17
	x, y := <-c, <-c        // 두 고루틴 결과 수신
	fmt.Println(x, y, x+y)  // 순서는 비결정적

	// 버퍼드 채널: 버퍼 크기 안에서 수신자 없이도 전송 가능
	buf := make(chan int, 3)
	buf <- 1
	buf <- 2
	buf <- 3
	// buf <- 4  // 버퍼 꽉 참 → 데드락
	fmt.Println(<-buf) // 1
	fmt.Println(<-buf) // 2
}

select로 타임아웃 구현
package main

import (
	"fmt"
	"time"
)

func slowOperation() <-chan string {
	result := make(chan string)
	go func() {
		time.Sleep(2 * time.Second) // 느린 작업 시뮬레이션
		result <- "작업 완료"
	}()
	return result
}

func main() {
	resultCh := slowOperation()

	select {
	case msg := <-resultCh:
		fmt.Println("결과:", msg)
	case <-time.After(1 * time.Second): // 1초 후 타임아웃 채널
		fmt.Println("타임아웃: 작업이 너무 오래 걸립니다")
	}

	// default 케이스 — 논블로킹 조회
	ch := make(chan int, 1)
	ch <- 42
	select {
	case v := <-ch:
		fmt.Println("값 수신:", v)
	default:
		fmt.Println("채널이 비어 있음")
	}
}

컨텍스트로 취소·타임아웃 제어
package main

import (
	"context"
	"fmt"
	"time"
)

func fetchData(ctx context.Context, id int) (string, error) {
	// 실제로는 DB 쿼리나 HTTP 요청이 들어가는 자리
	select {
	case <-time.After(500 * time.Millisecond): // 작업 완료 시뮬레이션
		return fmt.Sprintf("데이터 %d", id), nil
	case <-ctx.Done(): // 컨텍스트 취소/타임아웃 감지
		return "", ctx.Err() // context.DeadlineExceeded 또는 context.Canceled
	}
}

func main() {
	// 타임아웃 컨텍스트 — 1초 안에 완료하지 않으면 취소
	ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
	defer cancel() // 반드시 cancel 호출해 리소스 해제

	result, err := fetchData(ctx, 42)
	if err != nil {
		fmt.Println("오류:", err) // 타임아웃이면 context.DeadlineExceeded
		return
	}
	fmt.Println("결과:", result)

	// 수동 취소 컨텍스트 — 조건 충족 시 직접 cancel()
	ctx2, cancel2 := context.WithCancel(context.Background())
	go func() {
		time.Sleep(200 * time.Millisecond)
		cancel2() // 200ms 후 수동 취소
	}()
	_, err2 := fetchData(ctx2, 99)
	fmt.Println("취소 결과:", err2) // context.Canceled
}

sync.Mutex, RWMutex, Once 실전 예시
package main

import (
	"fmt"
	"sync"
)

// sync.Mutex — 안전한 카운터
type SafeCounter struct {
	mu sync.Mutex
	v  map[string]int
}

func (c *SafeCounter) Inc(key string) {
	c.mu.Lock()
	defer c.mu.Unlock()
	c.v[key]++
}

// sync.RWMutex — 읽기 많은 캐시
type Cache struct {
	mu   sync.RWMutex
	data map[string]string
}

func (c *Cache) Get(key string) (string, bool) {
	c.mu.RLock() // 여러 고루틴이 동시에 읽기 가능
	defer c.mu.RUnlock()
	v, ok := c.data[key]
	return v, ok
}

func (c *Cache) Set(key, value string) {
	c.mu.Lock() // 쓰기는 단독 잠금
	defer c.mu.Unlock()
	c.data[key] = value
}

// sync.Once — 한 번만 실행
var (
	instance *Cache
	once     sync.Once
)

func GetInstance() *Cache {
	once.Do(func() {
		instance = &Cache{data: make(map[string]string)}
		fmt.Println("캐시 초기화 (딱 한 번)")
	})
	return instance
}

func main() {
	var wg sync.WaitGroup
	for i := 0; i < 5; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			c := GetInstance() // once.Do 덕분에 초기화는 한 번만
			c.Set("key", "value")
		}()
	}
	wg.Wait()
}

워커 풀 패턴 구현
package main

import (
	"context"
	"fmt"
	"time"
)

type Job struct {
	ID int
}

type Result struct {
	JobID  int
	Output string
}

// 워커: 작업 채널에서 일을 꺼내 결과 채널에 넣음
func worker(ctx context.Context, id int, jobs <-chan Job, results chan<- Result) {
	for {
		select {
		case job, ok := <-jobs:
			if !ok {
				return // 작업 채널이 닫히면 워커 종료
			}
			// 실제 작업 처리
			time.Sleep(50 * time.Millisecond)
			results <- Result{
				JobID:  job.ID,
				Output: fmt.Sprintf("워커%d가 작업%d 처리 완료", id, job.ID),
			}
		case <-ctx.Done():
			return // 컨텍스트 취소 시 워커 종료
		}
	}
}

func main() {
	const numWorkers = 3
	const numJobs = 10

	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	jobs := make(chan Job, numJobs)
	results := make(chan Result, numJobs)

	// 워커 풀 시작
	for w := 1; w <= numWorkers; w++ {
		go worker(ctx, w, jobs, results)
	}

	// 작업 투입
	for j := 1; j <= numJobs; j++ {
		jobs <- Job{ID: j}
	}
	close(jobs) // 작업 채널 닫기 → 워커에게 종료 신호

	// 결과 수집
	for r := 0; r < numJobs; r++ {
		res := <-results
		fmt.Println(res.Output)
	}
}