Go 고루틴/채널 완전 정리

Go code

package main

import (
	"fmt"
	"sync"
	"time"
)

func worker(id int, wg *sync.WaitGroup) {
	defer wg.Done()   // 완료 시 카운터 감소
	fmt.Printf("worker %d 시작
", id)
	time.Sleep(time.Duration(id) * 100 * time.Millisecond)
	fmt.Printf("worker %d 완료
", id)
}

// 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]++
}

func (c *SafeCounter) Value(key string) int {
	c.mu.Lock()
	defer c.mu.Unlock()
	return c.v[key]
}

func main() {
	// WaitGroup 기본 패턴
	var wg sync.WaitGroup

	for i := 1; i <= 5; i++ {
		wg.Add(1)
		go worker(i, &wg)
	}
	wg.Wait()
	fmt.Println("모든 worker 완료")

	// RWMutex — 읽기는 동시, 쓰기는 독점
	var rwmu sync.RWMutex
	data := make(map[string]string)

	// 쓰기
	rwmu.Lock()
	data["key"] = "value"
	rwmu.Unlock()

	// 읽기 (여러 고루틴 동시 가능)
	rwmu.RLock()
	fmt.Println(data["key"])
	rwmu.RUnlock()

	// SafeCounter 사용
	counter := SafeCounter{v: make(map[string]int)}
	for i := 0; i < 100; i++ {
		go counter.Inc("key")
	}
	time.Sleep(100 * time.Millisecond)
	fmt.Println("카운트:", counter.Value("key"))
}

Go code

package main

import (
	"fmt"
	"time"
)

func producer(ch chan<- int, n int) {
	for i := 0; i < n; i++ {
		ch <- i
		time.Sleep(50 * time.Millisecond)
	}
	close(ch) // 완료 시 채널 닫기
}

func main() {
	// Unbuffered channel — 동기적
	ch1 := make(chan int)
	go func() { ch1 <- 42 }()
	fmt.Println(<-ch1) // 42

	// Buffered channel — 비동기
	ch2 := make(chan string, 3)
	ch2 <- "a"
	ch2 <- "b"
	ch2 <- "c"
	fmt.Println(<-ch2, <-ch2, <-ch2)

	// for range로 채널 소비
	numCh := make(chan int, 10)
	go producer(numCh, 5)
	for n := range numCh {
		fmt.Printf("받음: %d
", n)
	}

	// select — 여러 채널 대기
	ch3 := make(chan string)
	ch4 := make(chan string)

	go func() { time.Sleep(100*time.Millisecond); ch3 <- "ch3" }()
	go func() { time.Sleep(200*time.Millisecond); ch4 <- "ch4" }()

	for i := 0; i < 2; i++ {
		select {
		case msg := <-ch3:
			fmt.Println("받음:", msg)
		case msg := <-ch4:
			fmt.Println("받음:", msg)
		case <-time.After(500 * time.Millisecond):
			fmt.Println("타임아웃")
		}
	}

	// Done 채널 패턴
	done := make(chan struct{})
	go func() {
		fmt.Println("백그라운드 작업")
		close(done)
	}()
	<-done
}

Go code

package main

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

// context를 첫 번째 인자로 받는 것이 Go 관례
func fetchData(ctx context.Context, url string) (string, error) {
	ch := make(chan string, 1)

	go func() {
		// 실제 HTTP 요청 시뮬레이션
		time.Sleep(200 * time.Millisecond)
		ch <- "data from " + url
	}()

	select {
	case data := <-ch:
		return data, nil
	case <-ctx.Done():
		return "", ctx.Err() // context.DeadlineExceeded or Canceled
	}
}

func main() {
	// 타임아웃 컨텍스트
	ctx, cancel := context.WithTimeout(
		context.Background(),
		150*time.Millisecond,
	)
	defer cancel() // 반드시 호출

	result, err := fetchData(ctx, "https://api.example.com")
	if err != nil {
		fmt.Println("실패:", err) // context deadline exceeded
	} else {
		fmt.Println("성공:", result)
	}

	// 취소 컨텍스트 — 수동 취소
	ctx2, cancel2 := context.WithCancel(context.Background())
	go func() {
		time.Sleep(100 * time.Millisecond)
		cancel2() // 취소 신호 전송
	}()

	select {
	case <-ctx2.Done():
		fmt.Println("취소됨:", ctx2.Err())
	case <-time.After(500 * time.Millisecond):
		fmt.Println("타임아웃")
	}

	// context.WithValue — 요청 범위 값 전달
	type keyType string
	ctx3 := context.WithValue(context.Background(),
		keyType("userID"), "user-123")

	if uid, ok := ctx3.Value(keyType("userID")).(string); ok {
		fmt.Println("사용자 ID:", uid)
	}
}

Go code

package main

import (
	"fmt"
	"sync"
	"sync/atomic"
)

// sync.Once — 딱 한 번만 실행 (lazy singleton)
type Database struct {
	conn string
}

var (
	db   *Database
	once sync.Once
)

func GetDB() *Database {
	once.Do(func() {
		fmt.Println("DB 초기화 (한 번만)")
		db = &Database{conn: "postgres://localhost:5432/mydb"}
	})
	return db
}

// atomic — 락 없는 원자적 연산
type AtomicCounter struct {
	value int64
}

func (c *AtomicCounter) Inc() {
	atomic.AddInt64(&c.value, 1)
}

func (c *AtomicCounter) Load() int64 {
	return atomic.LoadInt64(&c.value)
}

func (c *AtomicCounter) CompareAndSwap(old, new int64) bool {
	return atomic.CompareAndSwapInt64(&c.value, old, new)
}

func main() {
	// sync.Once 테스트
	var wg sync.WaitGroup
	for i := 0; i < 5; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			db := GetDB()
			fmt.Println("사용:", db.conn)
		}()
	}
	wg.Wait()

	// atomic counter
	counter := &AtomicCounter{}
	for i := 0; i < 1000; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			counter.Inc()
		}()
	}
	wg.Wait()
	fmt.Println("최종 카운트:", counter.Load()) // 1000

	// CAS (Compare-And-Swap) 패턴
	ok := counter.CompareAndSwap(1000, 0)
	fmt.Println("CAS 성공:", ok, "값:", counter.Load())
}

Go code

<span class="cm">// fuzzing 테스트 (Go 1.18+) 예제
// data/prompts.js의 생성 프롬프트로 상세 코드 생성 가능</span>
fun main() { println("fuzzing 테스트 (Go 1.18+)") }

Go code

package main

import (
	"context"
	"fmt"
	"math/rand"
	"time"
)

// 1. 타임아웃 컨텍스트
func fetchData(ctx context.Context, id int) (string, error) {
	// 실제 작업을 시뮬레이션하는 채널
	ch := make(chan string, 1)
	go func() {
		time.Sleep(time.Duration(rand.Intn(300)) * time.Millisecond)
		ch <- fmt.Sprintf("데이터-%d", id)
	}()

	select {
	case data := <-ch:
		return data, nil
	case <-ctx.Done():
		return "", ctx.Err() // context.DeadlineExceeded 또는 Canceled
	}
}

// 2. 취소 전파
func processItems(ctx context.Context, items []int) []string {
	results := make([]string, 0, len(items))
	for _, item := range items {
		select {
		case <-ctx.Done():
			fmt.Println("  작업 취소됨:", ctx.Err())
			return results
		default:
			data, err := fetchData(ctx, item)
			if err != nil {
				fmt.Printf("  항목 %d 실패: %v\n", item, err)
				continue
			}
			results = append(results, data)
			fmt.Printf("  항목 %d 완료: %s\n", item, data)
		}
	}
	return results
}

// 3. 값 전달 (요청 ID 등)
type contextKey string

const requestIDKey contextKey = "requestID"

func withRequestID(ctx context.Context, id string) context.Context {
	return context.WithValue(ctx, requestIDKey, id)
}

func getRequestID(ctx context.Context) string {
	if id, ok := ctx.Value(requestIDKey).(string); ok {
		return id
	}
	return "unknown"
}

func main() {
	// 타임아웃 컨텍스트: 200ms 제한
	fmt.Println("=== 타임아웃 테스트 ===")
	ctx, cancel := context.WithTimeout(context.Background(), 200*time.Millisecond)
	defer cancel()
	results := processItems(ctx, []int{1, 2, 3, 4, 5})
	fmt.Printf("완료된 항목: %d개\n\n", len(results))

	// 수동 취소
	fmt.Println("=== 수동 취소 테스트 ===")
	ctx2, cancel2 := context.WithCancel(context.Background())
	go func() {
		time.Sleep(100 * time.Millisecond)
		cancel2() // 100ms 후 취소
	}()
	processItems(ctx2, []int{10, 20, 30})

	// 값 전달
	fmt.Println("\n=== 요청 ID 전달 ===")
	ctx3 := withRequestID(context.Background(), "req-abc-123")
	fmt.Println("요청 ID:", getRequestID(ctx3))
}

Go code

package main

import (
	"fmt"
	"sync"
	"time"
)

// 1. Mutex: 동시 접근 보호
type SafeCounter struct {
	mu    sync.RWMutex // 읽기-쓰기 뮤텍스
	count map[string]int
}

func NewSafeCounter() *SafeCounter {
	return &SafeCounter{count: make(map[string]int)}
}

func (c *SafeCounter) Increment(key string) {
	c.mu.Lock()         // 쓰기 잠금
	defer c.mu.Unlock()
	c.count[key]++
}

func (c *SafeCounter) Get(key string) int {
	c.mu.RLock()        // 읽기 잠금 (여러 고루틴 동시 읽기 가능)
	defer c.mu.RUnlock()
	return c.count[key]
}

// 2. WaitGroup: 고루틴 완료 대기
func parallelFetch(urls []string) []string {
	var wg sync.WaitGroup
	results := make([]string, len(urls))

	for i, url := range urls {
		wg.Add(1)
		go func(idx int, u string) {
			defer wg.Done()
			time.Sleep(50 * time.Millisecond) // 네트워크 시뮬레이션
			results[idx] = fmt.Sprintf("[%d] %s 완료", idx, u)
		}(i, url)
	}

	wg.Wait() // 모든 고루틴 완료까지 대기
	return results
}

// 3. Once: 정확히 한 번만 실행
type Database struct {
	once     sync.Once
	connPool string
}

func (db *Database) Connect() string {
	db.once.Do(func() {
		fmt.Println("  DB 연결 풀 초기화 (한 번만 실행)")
		time.Sleep(100 * time.Millisecond) // 초기화 시뮬레이션
		db.connPool = "PostgreSQL://pool-ready"
	})
	return db.connPool
}

// 4. Pool: 객체 재사용
var bufferPool = sync.Pool{
	New: func() interface{} {
		fmt.Println("  새 버퍼 생성")
		return make([]byte, 0, 1024)
	},
}

func main() {
	// Mutex 테스트
	fmt.Println("=== SafeCounter ===")
	counter := NewSafeCounter()
	var wg sync.WaitGroup
	for i := 0; i < 100; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			counter.Increment("hits")
		}()
	}
	wg.Wait()
	fmt.Printf("hits = %d (기대값: 100)\n", counter.Get("hits"))

	// WaitGroup 테스트
	fmt.Println("\n=== Parallel Fetch ===")
	urls := []string{"api/users", "api/posts", "api/comments"}
	results := parallelFetch(urls)
	for _, r := range results {
		fmt.Println(" ", r)
	}

	// Once 테스트
	fmt.Println("\n=== Singleton DB ===")
	db := &Database{}
	for i := 0; i < 3; i++ {
		wg.Add(1)
		go func(n int) {
			defer wg.Done()
			conn := db.Connect()
			fmt.Printf("  고루틴 %d: %s\n", n, conn)
		}(i)
	}
	wg.Wait()

	// Pool 테스트
	fmt.Println("\n=== Buffer Pool ===")
	buf := bufferPool.Get().([]byte)
	buf = append(buf, "hello pool"...)
	fmt.Printf("  사용: %s\n", buf)
	bufferPool.Put(buf[:0]) // 초기화 후 반환
	buf2 := bufferPool.Get().([]byte) // 재사용 (새로 생성 안 함)
	_ = buf2
}

Go code

package main

import (
	"fmt"
	"sync"
	"time"
)

func worker(id int, wg *sync.WaitGroup) {
	defer wg.Done()
	fmt.Printf("워커 %d 시작\n", id)
	time.Sleep(100 * time.Millisecond)
	fmt.Printf("워커 %d 완료\n", id)
}

func main() {
	var wg sync.WaitGroup

	for i := 1; i <= 5; i++ {
		wg.Add(1)
		go worker(i, &wg)
	}

	wg.Wait() // 모든 고루틴 완료 대기
	fmt.Println("모든 워커 완료")
}

Go code

package main

import (
	"fmt"
	"sync"
)

func workerPool(numWorkers int, jobs <-chan int) <-chan int {
	results := make(chan int, len(jobs))
	var wg sync.WaitGroup

	for w := 0; w < numWorkers; w++ {
		wg.Add(1)
		go func(id int) {
			defer wg.Done()
			for job := range jobs {
				result := job * job // 작업 처리
				fmt.Printf("워커%d: %d → %d\n", id, job, result)
				results <- result
			}
		}(w)
	}

	go func() {
		wg.Wait()
		close(results)
	}()

	return results
}

func main() {
	jobs := make(chan int, 10)
	for i := 1; i <= 10; i++ {
		jobs <- i
	}
	close(jobs)

	results := workerPool(3, jobs)

	var total int
	for r := range results {
		total += r
	}
	fmt.Println("합계:", total)
}

Go code

package main

import (
	"fmt"
	"sync"
)

// Fan-Out: 여러 고루틴에 작업 분배
func fanOut(input <-chan int, workers int) []<-chan int {
	channels := make([]<-chan int, workers)
	for i := 0; i < workers; i++ {
		ch := make(chan int)
		channels[i] = ch
		go func() {
			defer close(ch)
			for n := range input {
				ch <- n * n
			}
		}()
	}
	return channels
}

// Fan-In: 여러 채널을 하나로 합침
func fanIn(channels ...<-chan int) <-chan int {
	merged := 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 { merged <- v }
		}(ch)
	}

	go func() { wg.Wait(); close(merged) }()
	return merged
}

func main() {
	input := make(chan int, 5)
	go func() {
		for i := 1; i <= 10; i++ { input <- i }
		close(input)
	}()

	outputs := fanOut(input, 3)
	merged := fanIn(outputs...)

	for result := range merged {
		fmt.Println(result)
	}
}

Go code

package main

import "fmt"

func generate(nums ...int) <-chan int {
	out := make(chan int)
	go func() {
		defer close(out)
		for _, n := range nums { out <- n }
	}()
	return out
}

func square(in <-chan int) <-chan int {
	out := make(chan int)
	go func() {
		defer close(out)
		for n := range in { out <- n * n }
	}()
	return out
}

func filter(in <-chan int, pred func(int) bool) <-chan int {
	out := make(chan int)
	go func() {
		defer close(out)
		for n := range in {
			if pred(n) { out <- n }
		}
	}()
	return out
}

func main() {
	// 파이프라인: 생성 → 제곱 → 필터(50 이하)
	pipeline := filter(
		square(generate(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)),
		func(n int) bool { return n <= 50 },
	)

	for v := range pipeline {
		fmt.Println(v) // 1 4 9 16 25 36 49
	}
}

Go code

package main

import (
	"context"
	"fmt"
	"sync"
)

// errgroup 간단 구현
type ErrGroup struct {
	wg   sync.WaitGroup
	mu   sync.Mutex
	err  error
	ctx  context.Context
	cancel context.CancelFunc
}

func WithContext(ctx context.Context) (*ErrGroup, context.Context) {
	ctx, cancel := context.WithCancel(ctx)
	return &ErrGroup{ctx: ctx, cancel: cancel}, ctx
}

func (g *ErrGroup) Go(fn func() error) {
	g.wg.Add(1)
	go func() {
		defer g.wg.Done()
		if err := fn(); err != nil {
			g.mu.Lock()
			if g.err == nil { g.err = err }
			g.mu.Unlock()
			g.cancel()
		}
	}()
}

func (g *ErrGroup) Wait() error {
	g.wg.Wait()
	return g.err
}

func main() {
	g, ctx := WithContext(context.Background())

	urls := []string{"url1", "url2", "url3"}
	for _, url := range urls {
		g.Go(func() error {
			select {
			case <-ctx.Done():
				return ctx.Err()
			default:
				fmt.Println("처리:", url)
				return nil
			}
		})
	}

	if err := g.Wait(); err != nil {
		fmt.Println("에러:", err)
	}
}

Go code

package main

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

func slowOperation(ctx context.Context) error {
	select {
	case <-time.After(5 * time.Second):
		fmt.Println("작업 완료")
		return nil
	case <-ctx.Done():
		fmt.Println("작업 취소됨:", ctx.Err())
		return ctx.Err()
	}
}

func main() {
	// 타임아웃 컨텍스트
	ctx, cancel := context.WithTimeout(
		context.Background(), 2*time.Second,
	)
	defer cancel() // 리소스 해제 보장

	if err := slowOperation(ctx); err != nil {
		fmt.Println("에러:", err)
	}

	// 값 전달 (요청 ID 등)
	type ctxKey string
	ctx2 := context.WithValue(context.Background(),
		ctxKey("requestID"), "req-123")

	if v := ctx2.Value(ctxKey("requestID")); v != nil {
		fmt.Println("요청 ID:", v)
	}
}

Go code

package main

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

// 채널 기반 타임아웃
func fetchWithTimeout(timeout time.Duration) (string, error) {
	ch := make(chan string, 1)

	go func() {
		time.Sleep(2 * time.Second) // 느린 작업 시뮬레이션
		ch <- "데이터"
	}()

	select {
	case result := <-ch:
		return result, nil
	case <-time.After(timeout):
		return "", fmt.Errorf("타임아웃: %v", timeout)
	}
}

// context 기반 타임아웃
func fetchWithContext(ctx context.Context) (string, error) {
	ch := make(chan string, 1)
	go func() {
		time.Sleep(500 * time.Millisecond)
		ch <- "빠른 응답"
	}()

	select {
	case result := <-ch:
		return result, nil
	case <-ctx.Done():
		return "", ctx.Err()
	}
}

func main() {
	// 1초 타임아웃 (2초 작업 → 타임아웃)
	_, err := fetchWithTimeout(1 * time.Second)
	fmt.Println(err) // 타임아웃

	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
	defer cancel()
	result, _ := fetchWithContext(ctx)
	fmt.Println(result) // 빠른 응답
}

Go code

package main

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

func parentTask(ctx context.Context) {
	childCtx, cancel := context.WithCancel(ctx)
	defer cancel()

	go childTask(childCtx, "A")
	go childTask(childCtx, "B")

	select {
	case <-ctx.Done():
		fmt.Println("부모 취소됨 → 자식들도 자동 취소")
	case <-time.After(5 * time.Second):
		fmt.Println("부모 완료")
	}
}

func childTask(ctx context.Context, name string) {
	for {
		select {
		case <-ctx.Done():
			fmt.Printf("자식 %s 종료: %v\n", name, ctx.Err())
			return
		case <-time.After(500 * time.Millisecond):
			fmt.Printf("자식 %s 작업 중...\n", name)
		}
	}
}

func main() {
	ctx, cancel := context.WithTimeout(
		context.Background(), 2*time.Second,
	)
	defer cancel()

	parentTask(ctx)
	time.Sleep(100 * time.Millisecond) // 정리 대기
}

Go code

package main

import (
	"fmt"
	"time"
)

func main() {
	ch1 := make(chan string)
	ch2 := make(chan string)

	go func() { time.Sleep(100 * time.Millisecond); ch1 <- "one" }()
	go func() { time.Sleep(200 * time.Millisecond); ch2 <- "two" }()

	// 먼저 도착하는 것 처리
	for i := 0; i < 2; i++ {
		select {
		case msg := <-ch1:
			fmt.Println("ch1:", msg)
		case msg := <-ch2:
			fmt.Println("ch2:", msg)
		}
	}

	// 논블로킹 수신
	ch := make(chan int, 1)
	select {
	case v := <-ch:
		fmt.Println("수신:", v)
	default:
		fmt.Println("데이터 없음 (논블로킹)")
	}

	// nil 채널로 case 비활성화
	var active chan int = nil
	select {
	case <-active: // nil 채널은 영원히 블로킹 → 이 case 무시됨
	case <-time.After(100 * time.Millisecond):
		fmt.Println("nil 채널은 무시됨")
	}
}

Go code

package main

import "fmt"

// 송신 전용: chan<-
func producer(out chan<- int) {
	for i := 0; i < 5; i++ {
		out <- i
	}
	close(out) // 생산자가 채널 소유 → 닫기 책임
}

// 수신 전용: <-chan
func consumer(in <-chan int) {
	for v := range in {
		fmt.Println("수신:", v)
	}
}

// 변환: 수신 → 처리 → 송신
func transform(in <-chan int, out chan<- string) {
	defer close(out)
	for v := range in {
		out <- fmt.Sprintf("#%d", v)
	}
}

func main() {
	nums := make(chan int, 5)
	strs := make(chan string, 5)

	go producer(nums)
	go transform(nums, strs)

	for s := range strs {
		fmt.Println(s)
	}
}

Go code

package main

import "fmt"

func main() {
	// 비버퍼: 송수신이 동시에 일어나야 함
	unbuf := make(chan int)
	go func() { unbuf <- 42 }()
	fmt.Println(<-unbuf)

	// 버퍼 채널: 버퍼 크기만큼 비동기 전송
	buf := make(chan int, 3)
	buf <- 1 // 블로킹 없음
	buf <- 2
	buf <- 3
	// buf <- 4 // 버퍼 가득 → 블로킹!

	fmt.Println(len(buf), cap(buf)) // 3 3

	// 세마포어로 활용
	sem := make(chan struct{}, 3) // 최대 3개 동시 실행
	for i := 0; i < 10; i++ {
		sem <- struct{}{} // 슬롯 획득
		go func(id int) {
			defer func() { <-sem }() // 슬롯 반환
			fmt.Printf("작업 %d 실행\n", id)
		}(i)
	}
	// 모든 슬롯 회수 대기
	for i := 0; i < cap(sem); i++ { sem <- struct{}{} }
}

Go code

package main

import "fmt"

func main() {
	ch := make(chan int, 3)
	ch <- 10
	ch <- 20
	close(ch)

	// 콤마-ok 패턴
	v, ok := <-ch
	fmt.Println(v, ok) // 10 true

	v, ok = <-ch
	fmt.Println(v, ok) // 20 true

	v, ok = <-ch
	fmt.Println(v, ok) // 0 false (닫힘)

	// range는 자동으로 닫힘 감지
	ch2 := make(chan string, 2)
	ch2 <- "a"
	ch2 <- "b"
	close(ch2)

	for msg := range ch2 {
		fmt.Println(msg)
	}

	// 닫힌 채널로 브로드캐스트
	done := make(chan struct{})
	for i := 0; i < 3; i++ {
		go func(id int) {
			<-done // 모든 고루틴이 동시에 깨어남
			fmt.Printf("고루틴 %d 시작\n", id)
		}(i)
	}
	close(done) // 브로드캐스트!
}

Go code

package main

import (
	"fmt"
	"time"
)

// 간단한 레이트 리미터
type RateLimiter struct {
	tokens chan struct{}
	ticker *time.Ticker
}

func NewRateLimiter(rate int, burst int) *RateLimiter {
	rl := &RateLimiter{
		tokens: make(chan struct{}, burst),
		ticker: time.NewTicker(time.Second / time.Duration(rate)),
	}
	// 초기 토큰 채우기
	for i := 0; i < burst; i++ {
		rl.tokens <- struct{}{}
	}
	// 토큰 보충
	go func() {
		for range rl.ticker.C {
			select {
			case rl.tokens <- struct{}{}:
			default: // 버킷 가득 참
			}
		}
	}()
	return rl
}

func (rl *RateLimiter) Wait() {
	<-rl.tokens
}

func (rl *RateLimiter) Stop() {
	rl.ticker.Stop()
}

func main() {
	limiter := NewRateLimiter(5, 3) // 초당 5개, 버스트 3
	defer limiter.Stop()

	for i := 0; i < 8; i++ {
		limiter.Wait()
		fmt.Printf("[%s] 요청 %d 처리\n",
			time.Now().Format("15:04:05.000"), i)
	}
}

Go code

package main

import (
	"fmt"
	"sync"
	"time"
)

type Semaphore struct {
	ch chan struct{}
}

func NewSemaphore(max int) *Semaphore {
	return &Semaphore{ch: make(chan struct{}, max)}
}

func (s *Semaphore) Acquire() { s.ch <- struct{}{} }
func (s *Semaphore) Release() { <-s.ch }

func main() {
	sem := NewSemaphore(3) // 최대 3개 동시 실행
	var wg sync.WaitGroup

	for i := 0; i < 10; i++ {
		wg.Add(1)
		go func(id int) {
			defer wg.Done()
			sem.Acquire()
			defer sem.Release()

			fmt.Printf("[%s] 작업 %d 시작\n",
				time.Now().Format("05.000"), id)
			time.Sleep(500 * time.Millisecond)
		}(i)
	}

	wg.Wait()
	fmt.Println("모든 작업 완료")
}

Go code

package main

import (
	"fmt"
	"sync"
)

// 뮤텍스: 공유 상태 보호
type MutexCounter struct {
	mu    sync.Mutex
	count int
}

func (c *MutexCounter) Inc() {
	c.mu.Lock()
	defer c.mu.Unlock()
	c.count++
}

// 채널: 상태 소유권 전달
type ChannelCounter struct {
	inc  chan struct{}
	get  chan int
}

func NewChannelCounter() *ChannelCounter {
	c := &ChannelCounter{
		inc: make(chan struct{}),
		get: make(chan int),
	}
	go func() { // 단일 고루틴이 상태 소유
		count := 0
		for {
			select {
			case <-c.inc:
				count++
			case c.get <- count:
			}
		}
	}()
	return c
}

func main() {
	// 뮤텍스 방식
	mc := &MutexCounter{}
	var wg sync.WaitGroup
	for i := 0; i < 1000; i++ {
		wg.Add(1)
		go func() { defer wg.Done(); mc.Inc() }()
	}
	wg.Wait()
	fmt.Println("뮤텍스:", mc.count)

	// 채널 방식
	cc := NewChannelCounter()
	for i := 0; i < 1000; i++ {
		wg.Add(1)
		go func() { defer wg.Done(); cc.inc <- struct{}{} }()
	}
	wg.Wait()
	fmt.Println("채널:", <-cc.get)
}

Go code

package main

import (
	"fmt"
	"sync"
	"sync/atomic"
)

func main() {
	var counter atomic.Int64
	var wg sync.WaitGroup

	for i := 0; i < 1000; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			counter.Add(1)
		}()
	}

	wg.Wait()
	fmt.Println("카운터:", counter.Load())

	// atomic.Value: 임의 타입 저장
	var config atomic.Value
	type Config struct {
		Debug bool
		Level int
	}
	config.Store(Config{Debug: true, Level: 3})

	cfg := config.Load().(Config)
	fmt.Printf("설정: %+v\n", cfg)

	// CompareAndSwap
	var flag atomic.Bool
	swapped := flag.CompareAndSwap(false, true)
	fmt.Println("CAS 성공:", swapped)      // true
	swapped = flag.CompareAndSwap(false, true)
	fmt.Println("CAS 재시도:", swapped)     // false
}

Go code

package main

import (
	"fmt"
	"sync"
)

type DB struct {
	Name string
}

var (
	dbInstance *DB
	dbOnce     sync.Once
)

func GetDB() *DB {
	dbOnce.Do(func() {
		fmt.Println("DB 초기화 (한 번만 실행)")
		dbInstance = &DB{Name: "PostgreSQL"}
	})
	return dbInstance
}

func main() {
	var wg sync.WaitGroup

	// 10개 고루틴이 동시에 호출해도 1번만 초기화
	for i := 0; i < 10; i++ {
		wg.Add(1)
		go func(id int) {
			defer wg.Done()
			db := GetDB()
			fmt.Printf("고루틴 %d: %s\n", id, db.Name)
		}(i)
	}

	wg.Wait()
}

Go code

package main

import (
	"bytes"
	"fmt"
	"sync"
)

var bufPool = sync.Pool{
	New: func() any {
		return new(bytes.Buffer)
	},
}

func process(data string) string {
	buf := bufPool.Get().(*bytes.Buffer)
	defer func() {
		buf.Reset()      // 반드시 초기화 후 반환
		bufPool.Put(buf)
	}()

	buf.WriteString("[처리됨] ")
	buf.WriteString(data)
	return buf.String()
}

func main() {
	var wg sync.WaitGroup

	for i := 0; i < 10; i++ {
		wg.Add(1)
		go func(id int) {
			defer wg.Done()
			result := process(fmt.Sprintf("데이터-%d", id))
			fmt.Println(result)
		}(i)
	}

	wg.Wait()
}

Go code

package main

import (
	"fmt"
	"sync"
	"time"
)

type Queue struct {
	items []int
	cond  *sync.Cond
}

func NewQueue() *Queue {
	return &Queue{cond: sync.NewCond(&sync.Mutex{})}
}

func (q *Queue) Enqueue(item int) {
	q.cond.L.Lock()
	defer q.cond.L.Unlock()
	q.items = append(q.items, item)
	q.cond.Signal() // 대기 중인 하나를 깨움
}

func (q *Queue) Dequeue() int {
	q.cond.L.Lock()
	defer q.cond.L.Unlock()
	for len(q.items) == 0 {
		q.cond.Wait() // 조건 대기 (잠금 해제 → 대기 → 잠금 획득)
	}
	item := q.items[0]
	q.items = q.items[1:]
	return item
}

func main() {
	q := NewQueue()

	// 소비자
	go func() {
		for i := 0; i < 5; i++ {
			val := q.Dequeue()
			fmt.Println("소비:", val)
		}
	}()

	// 생산자
	for i := 1; i <= 5; i++ {
		time.Sleep(200 * time.Millisecond)
		q.Enqueue(i)
		fmt.Println("생산:", i)
	}
	time.Sleep(100 * time.Millisecond)
}

Go code

package main

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

// 나쁜 예: 고루틴 누수
func leakyFunc() <-chan int {
	ch := make(chan int)
	go func() {
		for i := 0; ; i++ {
			ch <- i // 소비자가 없으면 영원히 블로킹
		}
	}()
	return ch
}

// 좋은 예: context로 취소
func safeFunc(ctx context.Context) <-chan int {
	ch := make(chan int)
	go func() {
		defer close(ch)
		for i := 0; ; i++ {
			select {
			case ch <- i:
			case <-ctx.Done():
				fmt.Println("고루틴 정상 종료")
				return
			}
		}
	}()
	return ch
}

func main() {
	ctx, cancel := context.WithTimeout(
		context.Background(), 500*time.Millisecond,
	)
	defer cancel()

	ch := safeFunc(ctx)
	for i := 0; i < 3; i++ {
		fmt.Println(<-ch)
	}
	cancel() // 명시적 취소
	time.Sleep(100 * time.Millisecond)
	fmt.Println("완료")
}