Go 성능 완전 정리

Go code

package main

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

// sync.Pool — 임시 객체 재사용 (GC 시 해제될 수 있음)
var bufPool = sync.Pool{
	New: func() interface{} {
		return new(bytes.Buffer)
	},
}

func processRequest(data string) string {
	// 풀에서 버퍼 가져오기
	buf := bufPool.Get().(*bytes.Buffer)
	defer func() {
		buf.Reset()
		bufPool.Put(buf) // 풀에 반환
	}()

	buf.WriteString("처리: ")
	buf.WriteString(data)
	return buf.String()
}

// 슬라이스 미리 할당
func efficientAppend(n int) []int {
	// Bad: 매번 재할당
	// result := []int{}
	// for i := 0; i < n; i++ { result = append(result, i) }

	// Good: 미리 용량 할당
	result := make([]int, 0, n)
	for i := 0; i < n; i++ {
		result = append(result, i)
	}
	return result
}

// 문자열 변환 최적화
func buildString(parts []string) string {
	// Bad: + 연산자 (매번 새 문자열)
	// s := ""
	// for _, p := range parts { s += p }

	// Good: strings.Builder
	var sb strings.Builder
	sb.Grow(len(parts) * 10) // 예상 크기 예약
	for _, p := range parts { sb.WriteString(p) }
	return sb.String()
}

func main() {
	results := make([]string, 5)
	for i := 0; i < 5; i++ {
		results[i] = processRequest(fmt.Sprintf("req-%d", i))
	}
	for _, r := range results { fmt.Println(r) }

	nums := efficientAppend(100)
	fmt.Println("첫:", nums[0], "마지막:", nums[99])
}

Go code

// main.go — HTTP 서버에 pprof 연결
package main

import (
	"log"
	"net/http"
	_ "net/http/pprof"   // 이 import만으로 /debug/pprof 활성화
	"runtime/pprof"
	"os"
)

func main() {
	// CPU 프로파일링 (파일로 저장)
	f, err := os.Create("cpu.prof")
	if err != nil { log.Fatal(err) }
	defer f.Close()

	pprof.StartCPUProfile(f)
	defer pprof.StopCPUProfile()

	// 메모리 프로파일링
	defer func() {
		mf, _ := os.Create("mem.prof")
		defer mf.Close()
		pprof.WriteHeapProfile(mf)
	}()

	// 실제 애플리케이션 코드
	heavyWork()

	// HTTP 서버에서 실시간 프로파일링
	go func() {
		log.Println(http.ListenAndServe(":6060", nil))
	}()
	// curl http://localhost:6060/debug/pprof/
}

func heavyWork() {
	s := make([]int, 0)
	for i := 0; i < 1_000_000; i++ {
		s = append(s, i*i)
	}
}

// 분석 명령어:
// go test -cpuprofile=cpu.prof -memprofile=mem.prof -bench=.
// go tool pprof cpu.prof
// go tool pprof -http=:8080 cpu.prof  // 웹 UI
// (pprof) top10
// (pprof) list functionName
// (pprof) web

Go code

<span class="cm">// 프로파일 가이드 최적화 (PGO) 예제
// data/prompts.js의 생성 프롬프트로 상세 코드 생성 가능</span>
fun main() { println("프로파일 가이드 최적화 (PGO)") }

Go code

package main

import (
	"fmt"
	"runtime"
)

// === 빌드 태그 예제 ===

// 파일: config_prod.go
// //go:build prod
// package main
// var AppMode = "production"

// 파일: config_dev.go
// //go:build !prod
// package main
// var AppMode = "development"

// 파일: platform_linux.go
// //go:build linux
// func platformInfo() string { return "Linux 최적화 경로 사용" }

// 파일: platform_windows.go
// //go:build windows
// func platformInfo() string { return "Windows API 사용" }

// 파일: platform_default.go
// //go:build !linux && !windows
// func platformInfo() string { return "범용 구현 사용" }

func main() {
	// 현재 빌드 정보
	fmt.Printf("OS:   %s\n", runtime.GOOS)
	fmt.Printf("Arch: %s\n", runtime.GOARCH)
	fmt.Printf("CPUs: %d\n", runtime.NumCPU())
	fmt.Printf("Go:   %s\n", runtime.Version())

	fmt.Println("\n=== 크로스 컴파일 명령어 ===")
	targets := []struct{ os, arch, desc string }{
		{"linux", "amd64", "Linux x86_64 서버"},
		{"linux", "arm64", "Linux ARM (AWS Graviton)"},
		{"darwin", "arm64", "macOS Apple Silicon"},
		{"windows", "amd64", "Windows x86_64"},
		{"linux", "amd64", "정적 바이너리 (Alpine/scratch)"},
	}

	for _, t := range targets {
		cmd := fmt.Sprintf("GOOS=%s GOARCH=%s go build -o app-%s-%s",
			t.os, t.arch, t.os, t.arch)
		if t.desc == "정적 바이너리 (Alpine/scratch)" {
			cmd = "CGO_ENABLED=0 " + cmd + "-static"
		}
		fmt.Printf("  %-50s # %s\n", cmd, t.desc)
	}

	fmt.Println("\n=== 빌드 태그 사용 ===")
	fmt.Println("  go build -tags prod           # 프로덕션 모드")
	fmt.Println("  go build -tags 'prod metrics'  # 여러 태그")
	fmt.Println("  go build -ldflags '-s -w'      # 디버그 정보 제거 (바이너리 축소)")

	fmt.Println("\n=== Dockerfile 예제 ===")
	dockerfile := "# Multi-stage 빌드\n" +
		"FROM golang:1.22-alpine AS builder\n" +
		"WORKDIR /app\n" +
		"COPY go.* ./\n" +
		"RUN go mod download\n" +
		"COPY . .\n" +
		"RUN CGO_ENABLED=0 go build -ldflags='-s -w' -o /server\n" +
		"FROM scratch\n" +
		"COPY --from=builder /server /server\n" +
		"ENTRYPOINT [\"/server\"]"
	fmt.Println(dockerfile)
}

Go code

package main

import (
	"fmt"
	"os"
	"runtime/pprof"
)

func heavyWork() int {
	sum := 0
	for i := 0; i < 10_000_000; i++ {
		sum += i * i
	}
	return sum
}

func main() {
	// CPU 프로파일 생성
	f, _ := os.Create("cpu.prof")
	defer f.Close()

	pprof.StartCPUProfile(f)
	defer pprof.StopCPUProfile()

	// 프로파일할 코드
	result := heavyWork()
	fmt.Println("결과:", result)

	fmt.Println("\n프로파일 분석:")
	fmt.Println("  go tool pprof cpu.prof")
	fmt.Println("  (pprof) top 10           # 상위 10개 함수")
	fmt.Println("  (pprof) list heavyWork   # 함수별 상세")
	fmt.Println("  (pprof) web              # 웹 시각화")
	fmt.Println()
	fmt.Println("HTTP 서버에서:")
	fmt.Println("  import _ "net/http/pprof"")
	fmt.Println("  go tool pprof http://localhost:6060/debug/pprof/profile?seconds=30")

	os.Remove("cpu.prof")
}

Go code

package main

import (
	"fmt"
	"os"
	"runtime"
	"runtime/pprof"
)

func allocateSlices() {
	var data [][]byte
	for i := 0; i < 1000; i++ {
		buf := make([]byte, 10240) // 10KB
		data = append(data, buf)
	}
	_ = data
}

func main() {
	allocateSlices()

	// 힙 프로파일 생성
	f, _ := os.Create("mem.prof")
	defer f.Close()

	runtime.GC() // GC 실행 후 프로파일링
	pprof.WriteHeapProfile(f)

	// 메모리 통계
	var m runtime.MemStats
	runtime.ReadMemStats(&m)
	fmt.Printf("힙 할당: %d MB\n", m.HeapAlloc/1024/1024)
	fmt.Printf("시스템 메모리: %d MB\n", m.Sys/1024/1024)
	fmt.Printf("GC 횟수: %d\n", m.NumGC)

	fmt.Println("\n분석 명령어:")
	fmt.Println("  go tool pprof mem.prof")
	fmt.Println("  (pprof) top --alloc_space     # 총 할당량 기준")
	fmt.Println("  (pprof) top --inuse_space      # 현재 사용 기준")
	fmt.Println("  go tool pprof -http=:8080 mem.prof  # 웹 UI")

	os.Remove("mem.prof")
}

Go code

package main

import (
	"fmt"
	"os"
	"runtime/trace"
	"sync"
)

func main() {
	f, _ := os.Create("trace.out")
	defer f.Close()

	trace.Start(f)
	defer trace.Stop()

	// 트레이싱할 코드
	var wg sync.WaitGroup
	for i := 0; i < 10; i++ {
		wg.Add(1)
		go func(id int) {
			defer wg.Done()
			sum := 0
			for j := 0; j < 1000000; j++ {
				sum += j
			}
			_ = sum
		}(i)
	}
	wg.Wait()

	fmt.Println("트레이스 분석:")
	fmt.Println("  go tool trace trace.out")
	fmt.Println()
	fmt.Println("확인 항목:")
	fmt.Println("  - 고루틴 스케줄링 (Goroutine analysis)")
	fmt.Println("  - GC 일시 정지 시간")
	fmt.Println("  - 네트워크/시스템 호출 블로킹")
	fmt.Println("  - 고루틴 간 동기화 대기 시간")

	os.Remove("trace.out")
}

Go code

package main

import "fmt"

func main() {
	fmt.Println("=== 벤치마크 분석 워크플로우 ===")
	fmt.Println()
	fmt.Println("1. 벤치마크 실행 (최소 5회):")
	fmt.Println("  go test -bench=. -count=5 > old.txt")
	fmt.Println()
	fmt.Println("2. 코드 최적화 후 재실행:")
	fmt.Println("  go test -bench=. -count=5 > new.txt")
	fmt.Println()
	fmt.Println("3. 통계 비교:")
	fmt.Println("  benchstat old.txt new.txt")
	fmt.Println()
	fmt.Println("출력 예시:")
	fmt.Println("  name       old time/op  new time/op  delta")
	fmt.Println("  Process-8  1.50ms ± 2%  0.85ms ± 1%  -43.33%")
	fmt.Println()
	fmt.Println("4. 메모리 포함 분석:")
	fmt.Println("  go test -bench=. -benchmem -count=5 > result.txt")
	fmt.Println()
	fmt.Println("설치:")
	fmt.Println("  go install golang.org/x/perf/cmd/benchstat@latest")
}

Go code

package main

import (
	"fmt"
	"strings"
)

func main() {
	n := 10000

	// 나쁜 예: 반복적 재할당
	s1 := make([]int, 0)
	for i := 0; i < n; i++ {
		s1 = append(s1, i) // 용량 초과 시 매번 재할당
	}

	// 좋은 예: 사전 할당
	s2 := make([]int, 0, n)
	for i := 0; i < n; i++ {
		s2 = append(s2, i) // 재할당 없음
	}

	// 맵 사전 할당
	m := make(map[string]int, n) // 힌트 제공
	for i := 0; i < n; i++ {
		m[fmt.Sprintf("key%d", i)] = i
	}

	// 문자열 빌더 사전 할당
	var sb strings.Builder
	sb.Grow(n * 10) // 예상 크기만큼 미리 할당
	for i := 0; i < n; i++ {
		fmt.Fprintf(&sb, "item%d,", i)
	}

	fmt.Printf("슬라이스: len=%d, cap=%d\n", len(s2), cap(s2))
	fmt.Printf("맵: len=%d\n", len(m))
	fmt.Printf("문자열: len=%d\n", sb.Len())
}

Go code

package main

import (
	"bytes"
	"fmt"
	"strings"
)

func concatPlus(n int) string {
	s := ""
	for i := 0; i < n; i++ {
		s += "x" // 매번 새 문자열 생성 (O(n²))
	}
	return s
}

func concatBuilder(n int) string {
	var sb strings.Builder
	sb.Grow(n) // 사전 할당
	for i := 0; i < n; i++ {
		sb.WriteByte('x')
	}
	return sb.String()
}

func concatBuffer(n int) string {
	var buf bytes.Buffer
	buf.Grow(n)
	for i := 0; i < n; i++ {
		buf.WriteByte('x')
	}
	return buf.String()
}

func main() {
	n := 10000
	fmt.Println("+ 연산자:", len(concatPlus(n)))
	fmt.Println("Builder:", len(concatBuilder(n)))
	fmt.Println("Buffer:", len(concatBuffer(n)))

	// strings.Join도 효율적
	parts := make([]string, n)
	for i := range parts { parts[i] = "x" }
	result := strings.Join(parts, "")
	fmt.Println("Join:", len(result))
}

Go code

package main

import (
	"fmt"
	"testing"
)

func withoutPrealloc(n int) []int {
	var s []int // cap=0
	for i := 0; i < n; i++ {
		s = append(s, i) // 용량 초과 시 매번 재할당
	}
	return s
}

func withPrealloc(n int) []int {
	s := make([]int, 0, n) // cap=n
	for i := 0; i < n; i++ {
		s = append(s, i) // 재할당 없음
	}
	return s
}

func BenchmarkWithout(b *testing.B) {
	for i := 0; i < b.N; i++ {
		withoutPrealloc(10000)
	}
}

func BenchmarkWith(b *testing.B) {
	for i := 0; i < b.N; i++ {
		withPrealloc(10000)
	}
}

func main() {
	s1 := withoutPrealloc(8)
	s2 := withPrealloc(8)
	fmt.Printf("미할당: len=%d, cap=%d\n", len(s1), cap(s1))
	fmt.Printf("사전할당: len=%d, cap=%d\n", len(s2), cap(s2))

	// 변환 시 사전 할당
	src := []int{1, 2, 3, 4, 5}
	dst := make([]string, 0, len(src))
	for _, n := range src {
		dst = append(dst, fmt.Sprint(n))
	}
	fmt.Println(dst)
}

Go code

package main

import (
	"fmt"
	"testing"
)

func mapWithoutHint(n int) map[int]int {
	m := make(map[int]int) // 기본 크기
	for i := 0; i < n; i++ {
		m[i] = i * i
	}
	return m
}

func mapWithHint(n int) map[int]int {
	m := make(map[int]int, n) // 크기 힌트
	for i := 0; i < n; i++ {
		m[i] = i * i
	}
	return m
}

func BenchmarkMapWithout(b *testing.B) {
	for i := 0; i < b.N; i++ {
		mapWithoutHint(10000)
	}
}

func BenchmarkMapWith(b *testing.B) {
	for i := 0; i < b.N; i++ {
		mapWithHint(10000)
	}
}

func main() {
	m1 := mapWithoutHint(100)
	m2 := mapWithHint(100)
	fmt.Println("크기:", len(m1), len(m2))

	// maps.Clone (Go 1.21+)
	// import "maps"
	// m3 := maps.Clone(m1)
	fmt.Println("맵 사전 할당으로 리사이징 횟수 감소")
}

Go code

package main

import (
	"fmt"
	"sync"
)

type Pool struct {
	tasks chan func()
	wg    sync.WaitGroup
}

func NewPool(workers int) *Pool {
	p := &Pool{tasks: make(chan func(), workers*2)}
	for i := 0; i < workers; i++ {
		p.wg.Add(1)
		go func() {
			defer p.wg.Done()
			for task := range p.tasks {
				task()
			}
		}()
	}
	return p
}

func (p *Pool) Submit(task func()) {
	p.tasks <- task
}

func (p *Pool) Close() {
	close(p.tasks)
	p.wg.Wait()
}

func main() {
	pool := NewPool(4) // 4개 워커

	var mu sync.Mutex
	results := make([]int, 0, 100)

	for i := 0; i < 100; i++ {
		n := i
		pool.Submit(func() {
			result := n * n
			mu.Lock()
			results = append(results, result)
			mu.Unlock()
		})
	}

	pool.Close()
	fmt.Printf("처리 완료: %d건\n", len(results))
}

Go code

package main

import (
	"fmt"
	"runtime"
	"runtime/debug"
)

func main() {
	// 현재 GC 설정 확인
	fmt.Println("GOGC:", debug.SetGCPercent(-1))
	debug.SetGCPercent(100) // 기본값 복원

	// GC 통계
	var stats debug.GCStats
	debug.ReadGCStats(&stats)
	fmt.Printf("GC 횟수: %d\n", stats.NumGC)
	if len(stats.Pause) > 0 {
		fmt.Printf("마지막 GC 일시정지: %v\n", stats.Pause[0])
	}

	// GOMEMLIMIT 설정 (Go 1.19+)
	// 컨테이너 환경에서 메모리 제한
	debug.SetMemoryLimit(512 * 1024 * 1024) // 512MB

	// 메모리 통계
	var m runtime.MemStats
	runtime.ReadMemStats(&m)
	fmt.Printf("힙 사용: %d MB\n", m.HeapAlloc/1024/1024)
	fmt.Printf("힙 시스템: %d MB\n", m.HeapSys/1024/1024)
	fmt.Printf("GC CPU 비율: %.2f%%\n", m.GCCPUFraction*100)

	fmt.Println("\n환경 변수:")
	fmt.Println("  GOGC=200       # GC 빈도 감소 (메모리 ↑, CPU ↓)")
	fmt.Println("  GOGC=50        # GC 빈도 증가 (메모리 ↓, CPU ↑)")
	fmt.Println("  GOMEMLIMIT=512MiB  # 메모리 제한 (Go 1.19+)")
	fmt.Println("  GOGC=off GOMEMLIMIT=1GiB  # 소프트 메모리 제한만 사용")
}

Go code

package main

import "fmt"

// 스택에 할당됨 (이스케이프 안 함)
func stackAlloc() int {
	x := 42 // 스택
	return x
}

// 힙에 할당됨 (이스케이프)
func heapAlloc() *int {
	x := 42 // 힙으로 이스케이프 (포인터가 반환됨)
	return &x
}

// 인터페이스로 이스케이프
func interfaceEscape() {
	x := 42
	fmt.Println(x) // x가 any로 박싱 → 힙 할당
}

// 이스케이프 방지 패턴
type Result struct {
	Value int
	Err   error
}

func compute() Result {
	return Result{Value: 42} // 값 반환 → 스택 유지
}

func main() {
	fmt.Println(stackAlloc())
	fmt.Println(*heapAlloc())
	fmt.Println(compute())

	fmt.Println("\n이스케이프 분석 확인:")
	fmt.Println("  go build -gcflags='-m' main.go")
	fmt.Println("  go build -gcflags='-m -m' main.go  # 더 상세")
}

Go code

package main

import "fmt"

// 인라인 가능 (작은 함수)
func add(a, b int) int {
	return a + b
}

// 인라인 가능
func max(a, b int) int {
	if a > b { return a }
	return b
}

// 인라인 불가 (복잡한 함수)
func complexFunc(n int) int {
	sum := 0
	for i := 0; i < n; i++ {
		switch {
		case i%15 == 0: sum += 15
		case i%3 == 0:  sum += 3
		case i%5 == 0:  sum += 5
		default:        sum += i
		}
	}
	return sum
}

//go:noinline // 인라인 비활성화 (벤치마크용)
func addNoInline(a, b int) int {
	return a + b
}

func main() {
	fmt.Println(add(1, 2))
	fmt.Println(max(3, 5))

	fmt.Println("\n인라인 확인:")
	fmt.Println("  go build -gcflags='-m' main.go")
	fmt.Println("  'can inline add' → 인라인 가능")
	fmt.Println("  'inlining call to add' → 실제 인라인됨")
	fmt.Println()
	fmt.Println("Go 1.22+ mid-stack inlining 향상:")
	fmt.Println("  더 큰 함수도 인라인 가능")
}

Go code

package main

import "fmt"

func sum(nums []int) int {
	total := 0
	for _, n := range nums {
		total += n
	}
	return total
}

// 바운드 체크 제거 힌트
func sumOptimized(nums []int) int {
	total := 0
	for i := 0; i < len(nums); i++ {
		total += nums[i]
	}
	return total
}

func main() {
	nums := []int{1, 2, 3, 4, 5}
	fmt.Println(sum(nums))
	fmt.Println(sumOptimized(nums))

	fmt.Println("\n어셈블리 출력:")
	fmt.Println("  go build -gcflags='-S' main.go      # 전체 어셈블리")
	fmt.Println("  go tool compile -S main.go           # 파일별")
	fmt.Println("  go tool objdump -s 'main.sum' ./app  # 바이너리에서")
	fmt.Println()
	fmt.Println("Godbolt (https://godbolt.org)에서 온라인 확인 가능")
	fmt.Println()
	fmt.Println("바운드 체크 확인:")
	fmt.Println("  go build -gcflags='-d=ssa/check_bce/debug=1' main.go")
}

Go code

package main

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

type CacheItem[V any] struct {
	Value     V
	ExpiresAt time.Time
}

type Cache[K comparable, V any] struct {
	mu    sync.RWMutex
	items map[K]CacheItem[V]
	ttl   time.Duration
}

func NewCache[K comparable, V any](ttl time.Duration) *Cache[K, V] {
	return &Cache[K, V]{
		items: make(map[K]CacheItem[V]),
		ttl:   ttl,
	}
}

func (c *Cache[K, V]) Get(key K) (V, bool) {
	c.mu.RLock()
	defer c.mu.RUnlock()
	item, ok := c.items[key]
	if !ok || time.Now().After(item.ExpiresAt) {
		var zero V
		return zero, false
	}
	return item.Value, true
}

func (c *Cache[K, V]) Set(key K, value V) {
	c.mu.Lock()
	defer c.mu.Unlock()
	c.items[key] = CacheItem[V]{
		Value:     value,
		ExpiresAt: time.Now().Add(c.ttl),
	}
}

func main() {
	cache := NewCache[string, int](5 * time.Second)
	cache.Set("count", 42)

	if v, ok := cache.Get("count"); ok {
		fmt.Println("캐시 히트:", v)
	}

	if _, ok := cache.Get("missing"); !ok {
		fmt.Println("캐시 미스")
	}
}

Go code

package main

import "fmt"

func main() {
	fmt.Println("=== Go 프로파일링 도구 체인 ===")
	fmt.Println()
	fmt.Println("1. CPU 프로파일링:")
	fmt.Println("  go test -cpuprofile=cpu.prof -bench=.")
	fmt.Println("  go tool pprof -http=:8080 cpu.prof")
	fmt.Println()
	fmt.Println("2. 메모리 프로파일링:")
	fmt.Println("  go test -memprofile=mem.prof -bench=.")
	fmt.Println("  go tool pprof -http=:8080 mem.prof")
	fmt.Println()
	fmt.Println("3. 실행 트레이스:")
	fmt.Println("  go test -trace=trace.out -bench=.")
	fmt.Println("  go tool trace trace.out")
	fmt.Println()
	fmt.Println("4. 벤치마크 비교:")
	fmt.Println("  go test -bench=. -count=5 -benchmem | tee old.txt")
	fmt.Println("  benchstat old.txt new.txt")
	fmt.Println()
	fmt.Println("5. 컴파일러 분석:")
	fmt.Println("  go build -gcflags='-m'           # 이스케이프 분석")
	fmt.Println("  go build -gcflags='-m -l=4'      # 인라인 결정")
	fmt.Println("  go build -gcflags='-S'            # 어셈블리")
	fmt.Println()
	fmt.Println("6. 런타임 HTTP 프로파일링:")
	fmt.Println("  import _ "net/http/pprof"")
	fmt.Println("  go tool pprof http://localhost:6060/debug/pprof/heap")
	fmt.Println("  go tool pprof http://localhost:6060/debug/pprof/goroutine")
	fmt.Println()
	fmt.Println("최적화 순서: 측정 → 분석 → 개선 → 재측정")
}