できない.dev

Go の goroutine がリークして終了しない

受信側 goroutine が読み続けるべき channel を送信側が close せず、受信側が永久にブロックする状態が goroutine リーク。
context で停止信号を渡すか、送信終了側で close(ch) を呼んで for-range を抜けさせる。

公開: 更新:

症状できない · exit 1
go run bad_deadlock.go
…
fatal error: all goroutines are asleep - deadlock!
goroutine 1 [chan receive]:
main.main()
解決後できた · exit 0
go run solve_context.go
cancel 前の goroutine 数: 6
cancel 後の goroutine 数: 1

2026-10-14 に golang:1.23(Go 1.23.12) で実際に打って取った出力。検証環境の詳細

要約

Go の goroutine リークの原因は、ほぼ全てが「読み手が永久に待つ channel」か「停止信号を受け取れない無限ループ」である。
リークした goroutine はプロセスが終わるまで増え続け、メモリと CPU を蝕む。
基本の対策は 2 つあり、送信完了側で close(ch) を呼ぶ ことと、context.Context を渡して select で離脱できるようにすることである。

実行例

golang:1.23(Go 1.23.12)で上記の手順を動かすと、close(ch) を呼ばない送受信の組を 5 つ起動した後の goroutine 数は 1 から 6 に増えた。
main が待つ構成では、fatal error: all goroutines are asleep - deadlock! で終了コード 1 になった。
送信側で defer close(ch) すると 1 に戻った。
context.WithCancel の cancel を呼ぶと、待機中の goroutine が 6 から 1 に減った。
前後比較のテストは goroutine leak: 2 -> 5 で失敗した。

$ go run bad_close.go
起動直後の goroutine 数: 1
5 組の処理が終わった後の goroutine 数: 6
$ echo $?
0
$ go run bad_deadlock.go
recv 0
recv 1
recv 2
fatal error: all goroutines are asleep - deadlock!
 
goroutine 1 [chan receive]:
main.main()
	/tmp/leakdemo/bad_deadlock.go:12 +0xdf
exit status 2
$ echo $?
1
$ go run solve_close.go
起動直後の goroutine 数: 1
5 組の処理が終わった後の goroutine 数: 1
$ echo $?
0
$ go run solve_context.go
cancel 前の goroutine 数: 6
cancel 後の goroutine 数: 1
$ echo $?
0
$ go test
--- FAIL: TestNoLeak (0.05s)
    leak_test.go:22: goroutine leak: 2 -> 5
FAIL
exit status 1
FAIL	leaktest	0.052s
$ echo $?
1

— 2026-10-14 時点の出力

検証環境Python 3.11.2 / Git 2.39.5 / Go 1.23.12 / 2026-10-14 検証
検証日
実行環境
golang:1.23 Debian GNU/Linux 12 (bookworm)
バージョン
  • Python 3.11.2
  • Git 2.39.5
  • Go 1.23.12

この記事の「実行例」は、上記の環境で実際にコマンドを実行して得られた出力をそのまま掲載しています。 再現手順はリポジトリの検証スクリプトとして管理し、定期的に再実行して出力を更新しています。

解決策

1. 送信完了で close する

func produce(ch chan<- int) {
    defer close(ch)
    for i := 0; i < 10; i++ {
        ch <- i
    }
}
 
func consume(ch <-chan int) {
    for v := range ch {
        fmt.Println(v)
    }
}

range は close 後に自動で抜ける。
送信者が複数いる場合は sync.WaitGroup で同期し、最後の送信者が close を呼ぶ。

2. context で停止可能にする

func worker(ctx context.Context, ch <-chan int) {
    for {
        select {
        case <-ctx.Done():
            return
        case v, ok := <-ch:
            if !ok {
                return
            }
            handle(v)
        }
    }
}

context パッケージ(新しいタブで開く) を読み、子 goroutine には常に ctx を渡すパターンを徹底する。
キャンセル伝播のパイプライン全体は Go Concurrency Patterns: Pipelines and cancellation(新しいタブで開く) に網羅的に書かれている。

3. Ticker はループ外で作る

ticker := time.NewTicker(time.Second)
defer ticker.Stop()
for {
    select {
    case <-ctx.Done():
        return
    case <-ticker.C:
        do()
    }
}

time.Tick は Stop が呼べないため、長寿命のループでは time.NewTicker を使う。

4. リーク検出

before := runtime.NumGoroutine()
// 検証したい処理
after := runtime.NumGoroutine()
if after > before {
    t.Errorf("goroutine leak: %d -> %d", before, after)
}

テスト前後で runtime.NumGoroutine() を比較するヘルパーを CI に仕込むと、リーク混入 PR を早期に検知できる。
本番では net/http/pprof の /debug/pprof/goroutine で増加傾向を観察する。

よくある原因

  1. close されない channel がある。
    ワーカーが for v := range ch で待っているのに、送信側が close(ch) を忘れている。
  2. context が配線されていない。
    親が cancel() を呼んでも、goroutine 内で <-ctx.Done() を select していなければ離脱できない。
  3. ループの中で ticker を作り直している。
    ループ内で <-time.Tick(d) を書くと毎周新しい Ticker が生まれ、GC されない。
  4. WaitGroup の数がずれている。
    wg.Add(1) の前に goroutine を起動するとレースになり、Done の数が足りなくて Wait() が戻らない。