ドキュメント価格ブログ
お問い合わせ
ログイン無料で新規登録
Back to Tech Articles

Goのデータ競合検出器を深く掘り下げる：並行処理のバグを発掘する

9월 07, 2025
# Go

Min-jun Kim

Dev Intern · Leapcell

この記事はEnglish、한국어、Deutschでも利用できます
Cover of "Goのデータ競合検出器を深く掘り下げる：並行処理のバグを発掘する"

並行処理は諸刃の剣です。高いパフォーマンスとスケーラビリティを備えたアプリケーションの構築に計り知れない力を提供する一方で、見つけにくく再現性の低い、悪名高いバグの全く新しいクラスも導入します。データ競合とは、2つ以上のゴルーチンが同期なしに、同時に同じメモリ位置にアクセスし、少なくとも1つのアクセスが書き込みである場合に発生します。そのような操作の結果は非決定論的になり、微妙な論理エラー、データ破損、さらにはプログラムのクラッシュにつながる可能性があります。

幸いなことに、Goプログラミング言語は、強力なツールをそのまま提供するという哲学とともに、これらの捉えどころのない生き物を検出するための堅牢な組み込みメカニズムを備えています。それがデータ競合検出器です。go run、go build、またはgo testコマンドに-raceフラグを追加するだけで、Goはバイナリに楽器を組み込み、メモリへのアクセスを監視し、潜在的な競合状態を報告します。

go run -raceの威力

データ競合検出器の有効性を具体的な例で説明しましょう。ウェブサイトへの訪問者数を追跡するシナリオを考えてみてください。一般的でありながら欠陥のあるアプローチは、グローバルカウンターを使用することかもしれません。

package main

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

var visitorCount int

func incrementVisitorCount() {
	visitorCount++ // データ競合の可能性あり！
}

func main() {
	var wg sync.WaitGroup
	for i := 0; i < 1000; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			incrementVisitorCount()
		}()
	}
	wg.Wait()
	fmt.Println("Final visitor count:", visitorCount)
}

このコードをgo run main.goで実行すると、複数の実行で異なるFinal visitor countの値が観測される可能性があり、通常は1000未満になります。これは、複数のゴルーチンが同期なしにvisitorCountへの読み取り、インクリメント、書き込みを同時に試みているためです。visitorCount++操作はアトミックではありません。通常、読み取り、インクリメント、書き込みを含みます。2つのゴルーチンが同じ値を読み取り、それをインクリメントし、独立して書き戻した場合、インクリメントの1つが失われます。

次に、レース検出器を有効にして実行してみましょう。

go run -race main.go

以下のような（省略された）出力が表示されます。

==================
WARNING: DATA RACE
Read at 0x00c000016008 by goroutine 7:
  main.incrementVisitorCount()
      /path/to/your/project/main.go:12 +0x34

Previous write at 0x00c000016008 by goroutine 6:
  main.incrementVisitorCount()
      /path/to/your/project/main.go:12 +0x42

Goroutine 7 (running) created at:
  main.main()
      /path/to/your/project/main.go:21 +0x7a

Goroutine 6 (running) created at:
  main.main()
      /path/to/your/project/main.go:21 +0x7a
==================
WARNING: DATA RACE
Write at 0x00c000016008 by goroutine 8:
  main.incrementVisitorCount()
      /path/to/your/project/main.go:12 +0x42

Previous write at 0x00c000016008 by goroutine 7:
  main.incrementVisitorCount()
      /path/to/your/project/main.go:12 +0x42

Goroutine 8 (running) created at:
  main.main()
      /path/to/your/project/main.go:21 +0x7a

Goroutine 7 (running) created at:
  main.main()
      /path/to/your/project/main.go:21 +0x7a
==================
Found 2 data race(s)
Final visitor count: 998

出力は驚くほど明確で情報量が多いです。以下を特定します。

  1. 競合が発生した正確なメモリ​​アドレス（0x00c000016008）。
  2. 競合する操作：あるゴルーチンによる「読み取り」と、別のゴルーチンによる「以前の書き込み」（または「書き込み」と「以前の書き込み」）。
  3. これらの操作が行われたソースコードの正確な行番号（main.go:12）。
  4. 関与したゴルーチンとその作成スタックトレース。これにより、並行実行パスの起源をたどることができます。

この詳細なレポートにより、問題の診断と修正が大幅に容易になります。

同期によるデータ競合の解決

visitorCountの例のデータ競合を解決するには、適切な同期を導入する必要があります。Goは主にsyncパッケージを通じて、このためのいくつかのメカニズムを提供します。

1. sync.Mutexの使用

sync.Mutex（相互排他ロック）は、共有リソースを保護する最も一般的な方法です。一度に1つのゴルーチンしかロックを保持できず、排他アクセスを保証します。

package main

import (
	"fmt"
	"sync"
	"time" // 将来的なユースケースのために含まれていますが、この例では厳密には必要ありません
)

var visitorCount int
var mu sync.Mutex // visitorCountを保護するためのMutex

func incrementVisitorCountSafe() {
	mu.Lock()         // ロックを取得
	visitorCount++    // クリティカルセクション
	mu.Unlock()       // ロックを解放
}

func main() {
	var wg sync.WaitGroup
	for i := 0; i < 1000; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			incrementVisitorCountSafe()
		}()
	}
	wg.Wait()
	fmt.Println("Final visitor count:", visitorCount)
}

この修正されたコードでgo run -race main.goを実行すると、競合警告は表示されず、Final visitor countは一貫して1000になります。

2. sync/atomicパッケージの使用

基本的な型の単純な算術演算（整数など）の場合、sync/atomicパッケージは高度に最適化された低レベルのアトミック操作を提供します。これらの操作は、ロック/アンロックのオーバーヘッドが伴わないため、通常はミューテックスよりもパフォーマンスが高くなります。

package main

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

var visitorCount int64 // アトミック操作のためにint64を使用

func incrementVisitorCountAtomic() {
	atomic.AddInt64(&visitorCount, 1) // visitorCountに1をアトミックに追加
}

func main() {
	var wg sync.WaitGroup
	for i := 0; i < 1000; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			incrementVisitorCountAtomic()
		}()
	}
	wg.Wait()
	fmt.Println("Final visitor count:", atomic.LoadInt64(&visitorCount)) // 最終値をアトミックにロード
}

ここでも、go run -race main.goはデータ競合を示さず、カウントは1000になります。atomic.LoadInt64は、アトミックカウンタを安全に読み取るために使用されます。直接アクセス（visitorCount）は、別のゴルーチンが同時に書き込んでいる場合、依然として競合になります。

単純なカウンターを超えて：より複雑なシナリオ

データ競合は単純な整数インクリメントに限定されません。さまざまなシナリオで発生する可能性があります。たとえば、次のとおりです。

  • 保護なしの同時マップアクセス：Goのマップは、同時書き込み（または書き込みと読み取り）に対して安全ではありません。

    package main

import (
	"fmt"
	"sync"
)

var data = make(map[string]int)

func updateMapConcurrent(key string, value int) {
	data[key] = value // マップ書き込み時のデータ競合
}

func main() {
	var wg sync.WaitGroup
	for i := 0; i < 100; i++ {
		wg.Add(1)
		go func(i int) {
			defer wg.Done()
			updateMapConcurrent(fmt.Sprintf("key%d", i), i)
		}(i)
	}
	wg.Wait()
	// 読み取りも同時書き込みによる競合を引き起こす可能性があります
	fmt.Println("Map size:", len(data))
}

    go run -race main.goを実行すると、すぐに競合が明らかになります。解決策は、マップ操作の周りでsync.Mutexを使用するか、特定のユースケースでsync.Mapを使用することです。

  • 適切な同期なしにミュータブルデータ構造へのポインタを共有する：複数のゴルーチンが同じ構造体へのポインタを保持し、そのフィールドを同時に変更する場合。

    package main

import (
	"fmt"
	"sync"
)

type Person struct {
	Name string
	Age  int
}

func updateAge(p *Person, newAge int) {
	p.Age = newAge // 複数のゴルーチンが同じ*Personを更新する場合、データ競合
}

func main() {
	p := &Person{Name: "Alice", Age: 30}
	var wg sync.WaitGroup

	for i := 0; i < 10; i++ {
		wg.Add(1)
		go func(age int) {
			defer wg.Done()
			updateAge(p, age) // すべてのゴルーチンが*同じ*pを変更します
		}(30 + i)
	}
	wg.Wait()
	fmt.Println("Final Age:", p.Age) // 非決定論的
}

    ここでも、go run -race main.goがこれを捕捉します。解決策の1つは、Person構造体内にsync.Mutexを使用するか、変更が独立している場合はコピーを渡すことです。

  • 書き込み中のチャネルを閉じる：これはパニックにつながる可能性がありますが、競合検出器は潜在的なメモリ​​アクセス競合を捕捉できる場合があります。

データ競合検出器の使用に関するベストプラクティス

  1. テスト中は常に有効にする：-raceフラグは、単体テスト、統合テスト、エンドツーエンドテスト中に非常に役立ちます。CI/CDパイプライン（go test -race ./...）に含めることは、交渉の余地のないベストプラクティスです。
  2. さまざまなワークロードで実行する：ゴルーチンが実際にリソースを競合する場合、競合検出器は競合を見つける可能性が高くなります。高並行状況を作成するようにテストを設計します。
  3. 偽陽性/偽陰性を理解する：競合検出器は非常に効果的ですが、完璧ではありません。
    • 偽陽性：非常にまれですが、非常に特殊な低レベルのシナリオで発生する可能性があります。
    • 偽陰性：より一般的です。競合状態が存在しても、スケジューリング（例：ゴルーチンが常に単一コアで順次実行される、またはタイミングが合わない）によりヒットしない場合、検出器はそれを報告しません。そのため、さまざまな負荷やハードウェア/OS構成でテストすることが有益です。
  4. 競合が見つかったら修正する：競合レポートを無視しないでください。競合が無害に見えたり、現在のテストで「機能」したりしても、特に本番環境での負荷やシステム条件が異なる場合に、デバッグが困難な微妙な問題として非決定論性をもたらします。
  5. サードパーティライブラリに注意する：ライブラリを使用している場合、複数のゴルーチンからミュータブル状態にアクセスしている場合は、それらが並行処理で安全であることを確認してください。そうでない場合、それらへの呼び出しの周りに必要な同期を追加する責任があります。
  6. 本番バイナリのgo build -race？：-raceでビルドされたバイナリを本番環境にデプロイすることは、一般的に推奨されません。競合検出器は、インストルメンテーションのためにかなりのオーバーヘッド（CPUとメモリ）を追加します。その主な目的は、開発とテストのためです。

競合検出器の仕組み（概要）

Goの競合検出器は、Goの並行処理モデルに適応されたThreadSanitizer (TSan)ランタイムライブラリに基づいています。-raceでコンパイルすると、GoコンパイラはTSanランタイムライブラリへの呼び出しを、すべてのメモリアクセス（読み取りと書き込み）でコードに挿入します。TSanは次に、メモリ位置の状態（どのゴルーチンが最後にアクセスしたか、およびアクセスの種類）を追跡し、「Happens-before」メモリモデルを使用して、2つの競合するメモリアクセスが同期されていないかどうかを判断します。同じメモリ位置への2つのアクセスが同時に発生し、少なくとも1つが書き込みであり、それらの間の順序を確立する同期がない場合、TSanはデータ競合を報告します。

結論

データ競合は、ソフトウェアの信頼性を静かに破壊します。Goの組み込みデータ競合検出器（go run -race）は、開発者が開発サイクルの早い段階でこれらの悪質なバグを特定して排除できるようにする、不可欠なツールです。-raceを日常の開発ワークフローとCI/CDパイプラインに統合することで、並行Goアプリケーションの堅牢性と予測可能性を大幅に向上させ、より安定した、保守しやすく、信頼性の高いソフトウェアにつながります。-raceフラグを採用してください。それは並行処理の混乱に対するあなたの最前線の防御です。

Share this article

HackerNews

More Posts from Leapcell

cover

GoのContextパッケージの力を解き放つ：並行処理制御とリクエストメタデータの伝播

cover

サイレント契約：Goのエラーインターフェースデザインの解体

Popular Posts