Go言語入門：ガベージコレクター -Vol.14-

よっしー

こんにちは。よっしーです(^^)

本日は、Go言語のガベージコレクターついて解説しています。

背景

Goのガベージコレクター（GC）は、多くの開発者にとって「ブラックボックス」のような存在です。メモリ管理を自動で行ってくれる便利な仕組みである一方、アプリケーションのパフォーマンスに大きな影響を与える要因でもあります。「なぜ突然レスポンスが遅くなるのか？」「メモリ使用量が想定より多いのはなぜか？」「GCの停止時間をもっと短くできないか？」—— こうした疑問は、Goで高性能なアプリケーションを開発する上で避けて通れない課題です。

本記事では、Go公式ドキュメントの「ガベージコレクションガイド」を日本語で紹介します。このガイドは、GCの動作原理を理解し、その知見を活用してアプリケーションのリソース使用効率を改善することを目的としています。特筆すべきは、このドキュメントがガベージコレクションの前提知識を一切要求しない点です。Go言語の基本的な知識さえあれば、誰でもGCの仕組みを深く理解できるよう設計されています。

なぜ今、GCの理解が重要なのでしょうか。クラウドネイティブ時代において、リソースの効率的な活用はコスト削減に直結します。また、マイクロサービスアーキテクチャでは、各サービスのレイテンシが全体のユーザー体験に影響するため、GCによる一時停止を最小限に抑えることが求められます。このガイドを通じて、「なんとなく動いている」から「理解して最適化できる」レベルへとステップアップし、より高品質なGoアプリケーションの開発を目指しましょう。

A Guide to the Go Garbage Collector - The Go Programming Language

最適化ガイド

コストの特定

GoアプリケーションがGCとどのように相互作用するかを最適化しようとする前に、まずGCがそもそも主要なコストであることを特定することが重要です。

Goエコシステムは、コストを特定しGoアプリケーションを最適化するための多数のツールを提供しています。これらのツールの簡単な概要については、診断に関するガイドを参照してください。ここでは、これらのツールのサブセットと、GCの影響と動作を理解するためにそれらを適用する合理的な順序に焦点を当てます。

GC最適化ガイド – 始め方

パフォーマンス問題を解決する前に、本当にGCが問題なのかを確認する必要があります。

❌ 間違ったアプローチ

// 間違い: 測定せずに最適化
func badApproach() {
    // 「なんとなくGCが遅そう」
    // → GOGCを変更
    // → メモリプールを導入
    // → 効果があるかわからない...
    
    debug.SetGCPercent(200)  // これで速くなる?
}

✅ 正しいアプローチ

// 正しい: まず測定
func goodApproach() {
    // 1. 現状を測定
    // 2. GCが問題か特定
    // 3. どこが問題か特定
    // 4. 最適化
    // 5. 効果を測定
}

最適化の黄金律

┌─────────────────────────────────┐
│   測定 → 特定 → 最適化 → 検証   │
└─────────────────────────────────┘
    ↑                           │
    └───────────────────────────┘
          繰り返し

有名な格言:

“Premature optimization is the root of all evil” (時期尚早な最適化は諸悪の根源) — Donald Knuth

つまり:

測定せずに最適化しない
推測ではなくデータで判断
効果を必ず検証

ステップ1: 本当にGCが問題か?

チェックポイント

□ アプリケーションが遅い
□ CPU使用率が高い
□ レイテンシが高い
□ スループットが低い

でも、原因は?
→ GC?
→ データベース?
→ ネットワーク?
→ アルゴリズム?

最初の確認: GCメトリクス

package main

import (
    "fmt"
    "runtime"
)

func checkGCImpact() {
    var m runtime.MemStats
    runtime.ReadMemStats(&m)
    
    fmt.Println("=== GC統計 ===")
    fmt.Printf("GC実行回数: %d\n", m.NumGC)
    fmt.Printf("GC CPU時間: %v\n", 
        time.Duration(m.GCCPUFraction * float64(time.Second)))
    fmt.Printf("総一時停止時間: %v\n", 
        time.Duration(m.PauseTotalNs))
    
    // 判断基準
    if m.GCCPUFraction > 0.1 {
        fmt.Println("⚠️ GCがCPUの10%以上を使用!")
    }
    
    if m.NumGC > 1000 {
        fmt.Println("⚠️ GCが非常に頻繁!")
    }
}

簡単な判断基準

GCのCPU使用率:
< 5%:   ✅ 問題なし
5-10%:  ⚠️ 注意
10-25%: 🔴 最適化を検討
> 25%:  🔴 最適化が必要

GC頻度:
< 10回/秒:  ✅ 問題なし
10-50回/秒: ⚠️ 注意
> 50回/秒:  🔴 最適化が必要

Goの診断ツール一覧

Goは強力な診断ツールを提供しています。

基本ツール

ツール	用途	難易度
runtime.MemStats	メモリ統計	⭐
GODEBUG	GCトレース	⭐⭐
pprof	プロファイリング	⭐⭐⭐
trace	実行トレース	⭐⭐⭐⭐

ツールの使い方: 推奨順序

レベル1: runtime.MemStats (最も簡単)

いつ使う: 最初のチェック

package main

import (
    "fmt"
    "runtime"
    "time"
)

func monitorGC() {
    ticker := time.NewTicker(10 * time.Second)
    defer ticker.Stop()
    
    var lastNumGC uint32
    var lastPauseNs uint64
    
    for range ticker.C {
        var m runtime.MemStats
        runtime.ReadMemStats(&m)
        
        // この期間のGC回数
        gcCount := m.NumGC - lastNumGC
        pauseTime := time.Duration(m.PauseTotalNs - lastPauseNs)
        
        fmt.Printf("\n=== 過去10秒 ===\n")
        fmt.Printf("GC回数: %d\n", gcCount)
        fmt.Printf("GC一時停止: %v\n", pauseTime)
        fmt.Printf("ヒープサイズ: %d MB\n", 
            m.HeapAlloc/1024/1024)
        fmt.Printf("GC CPU使用率: %.2f%%\n", 
            m.GCCPUFraction*100)
        
        // 警告
        if gcCount > 50 {
            fmt.Println("⚠️ GCが頻繁すぎます")
        }
        if m.GCCPUFraction > 0.1 {
            fmt.Println("⚠️ GCのCPU使用率が高いです")
        }
        
        lastNumGC = m.NumGC
        lastPauseNs = m.PauseTotalNs
    }
}

func main() {
    go monitorGC()
    
    // アプリケーションのメイン処理
    // ...
}

何がわかるか:

GCの頻度
GCのCPU使用率
メモリ使用量
一時停止時間

レベル2: GODEBUG環境変数 (少し詳しく)

いつ使う: GCの詳細を見たい時

# GCの実行をリアルタイムで表示
GODEBUG=gctrace=1 go run main.go

# 出力例:
gc 1 @0.005s 0%: 0.018+1.3+0.076 ms clock, 0.15+0.59/1.2/3.0+0.61 ms cpu, 4->4->3 MB, 5 MB goal, 8 P

出力の読み方:

gc 1           # GC番号
@0.005s        # プログラム開始からの経過時間
0%             # GCのCPU使用率
4->4->3 MB     # GC前のヒープ->GC開始時->GC後のヒープ
5 MB goal      # 次のGCのターゲット
8 P            # プロセッサ数

便利なオプション:

# メモリのスキャベンジング(OS返却)を表示
GODEBUG=gctrace=1,scavtrace=1 go run main.go

# より詳細な情報
GODEBUG=gctrace=2 go run main.go

レベル3: pprof (プロファイリング)

いつ使う: どこでメモリを割り当てているか知りたい時

package main

import (
    "net/http"
    _ "net/http/pprof"  // pprofハンドラを登録
)

func main() {
    // pprofサーバーを起動
    go func() {
        http.ListenAndServe("localhost:6060", nil)
    }()
    
    // アプリケーションのメイン処理
    // ...
}

使い方:

# プログラムを実行中に...

# ヒーププロファイルを取得
go tool pprof http://localhost:6060/debug/pprof/heap

# インタラクティブモードで分析
(pprof) top
(pprof) list functionName
(pprof) web  # グラフ表示

# または、Webブラウザで
go tool pprof -http=:8080 http://localhost:6060/debug/pprof/heap

何がわかるか:

どの関数が多くメモリを割り当てているか
どこが最適化のターゲットか
メモリリークの可能性

レベル4: trace (実行トレース)

いつ使う: GCのタイミングと影響を詳しく見たい時

package main

import (
    "os"
    "runtime/trace"
)

func main() {
    // トレースを開始
    f, _ := os.Create("trace.out")
    defer f.Close()
    
    trace.Start(f)
    defer trace.Stop()
    
    // アプリケーションの処理
    // ...
}

分析:

# トレースファイルを解析
go tool trace trace.out

# ブラウザが開き、以下が見られる:
# - GCの実行タイミング
# - Goroutineの状態
# - プロセッサの使用状況
# - ブロッキング

何がわかるか:

GCがいつ実行されたか
GC中に何が起きたか
アプリケーションへの影響
ボトルネックの特定

実践例: 問題の特定

例1: Webサーバーが遅い

package main

import (
    "fmt"
    "log"
    "net/http"
    "runtime"
    "time"
)

func handler(w http.ResponseWriter, r *http.Request) {
    start := time.Now()
    
    // リクエスト処理
    processRequest()
    
    latency := time.Since(start)
    
    // レイテンシが高い場合、GCを疑う
    if latency > 100*time.Millisecond {
        var m runtime.MemStats
        runtime.ReadMemStats(&m)
        
        log.Printf("High latency: %v", latency)
        log.Printf("GC CPU: %.2f%%", m.GCCPUFraction*100)
        log.Printf("Recent GCs: %d", m.NumGC)
    }
    
    fmt.Fprintf(w, "OK")
}

func processRequest() {
    // リクエスト処理...
    time.Sleep(50 * time.Millisecond)
}

func main() {
    // 定期的なGC統計
    go func() {
        ticker := time.NewTicker(30 * time.Second)
        for range ticker.C {
            var m runtime.MemStats
            runtime.ReadMemStats(&m)
            
            log.Printf("=== GC Stats ===")
            log.Printf("NumGC: %d", m.NumGC)
            log.Printf("GCCPUFraction: %.2f%%", 
                m.GCCPUFraction*100)
            log.Printf("HeapAlloc: %d MB", 
                m.HeapAlloc/1024/1024)
        }
    }()
    
    http.HandleFunc("/", handler)
    log.Fatal(http.ListenAndServe(":8080", nil))
}

例2: バッチ処理が遅い

package main

import (
    "fmt"
    "runtime"
    "time"
)

func processBatch() {
    start := time.Now()
    
    // 初期状態を記録
    var m1 runtime.MemStats
    runtime.ReadMemStats(&m1)
    initialGC := m1.NumGC
    
    // バッチ処理
    for i := 0; i < 10000; i++ {
        data := make([]byte, 1024*1024)  // 1MB
        processData(data)
    }
    
    // 最終状態を記録
    var m2 runtime.MemStats
    runtime.ReadMemStats(&m2)
    
    duration := time.Since(start)
    gcCount := m2.NumGC - initialGC
    
    fmt.Printf("処理時間: %v\n", duration)
    fmt.Printf("GC回数: %d\n", gcCount)
    fmt.Printf("GC CPU: %.2f%%\n", m2.GCCPUFraction*100)
    
    // 判断
    if gcCount > 100 {
        fmt.Println("⚠️ GCが多すぎます")
        fmt.Println("→ メモリの再利用を検討")
    }
}

func processData(data []byte) {
    // データ処理...
}

診断のチェックリスト

□ runtime.MemStatsで基本統計を確認
□ GCCPUFractionが10%以下か?
□ GC頻度は適切か?
□ GODEBUGでGCの動作を観察
□ pprofでメモリ割り当てを分析
□ traceでタイミングを確認
□ ボトルネックを特定

次のステップ

問題を特定したら、次は最適化です:

メモリ割り当ての削減 – オブジェクトプール、事前割り当て
GOGCの調整 – GC頻度の最適化
メモリ制限の設定 – GOMEMLIMITの活用
データ構造の見直し – ポインタの削減

まとめ

ステップ	ツール	目的
1. 初期確認	MemStats	GCが問題か判断
2. 詳細観察	GODEBUG	GCの動作を見る
3. 原因特定	pprof	どこが問題か
4. タイミング	trace	いつ問題が起きるか

最重要原則:

まず測定、それから最適化!

次のセクションでは、具体的な最適化手法を学びます! 🚀

おわりに

本日は、Go言語のガベージコレクターについて解説しました。

よっしー

何か質問や相談があれば、コメントをお願いします。また、エンジニア案件の相談にも随時対応していますので、お気軽にお問い合わせください。

それでは、また明日お会いしましょう(^^)