Go言語のsync.WaitGroupで並行処理を効率的にテストする方法

Go言語は並行処理に特化した設計を持つプログラミング言語であり、その機能を活用することで高いパフォーマンスを発揮できます。特にsync.WaitGroupは、複数のgoroutineの同期を簡潔に実現できる便利なツールです。本記事では、Go言語の並行処理を効率的にテストするために、sync.WaitGroupの基本的な使い方からテストコードの実装例、エラー処理、さらには応用例まで、実践的な内容を詳しく解説します。これにより、並行処理を正確にテストし、予期せぬバグを防ぐスキルを身に付けられるでしょう。

Go言語の並行処理の基礎

Go言語は、軽量スレッドであるgoroutineを活用することで、簡単かつ効率的に並行処理を実現します。これにより、複数のタスクを同時に実行し、システムリソースを効果的に活用することができます。

goroutineとは

goroutineは、Goランタイムによって管理される軽量なスレッドです。以下の特徴があります：

低コスト：スレッドに比べて非常に少ないメモリを使用します。
簡単な構文：goキーワードを使用するだけで、関数を並行して実行可能です。

func main() {
    go func() {
        fmt.Println("Hello, goroutine!")
    }()
    fmt.Println("Hello, main!")
}

このコードでは、メイン関数と匿名関数が並行して実行されます。

チャネルと並行処理

Goではchan型を使用して、goroutine間でデータを安全にやり取りできます。これにより、競合状態を避けることが可能です。

func main() {
    ch := make(chan string)
    go func() {
        ch <- "Hello from goroutine!"
    }()
    fmt.Println(<-ch)
}

この例では、goroutineからメッセージを受信し、同期的に処理しています。

並行処理の課題

Go言語の並行処理は強力ですが、以下の課題があります：

デッドロック：複数のgoroutineが互いにリソースを待ち続ける状態。
競合状態：同時にアクセスするデータが正しく管理されない状態。
同期の難しさ：複数のgoroutine間での正確なタイミング管理。

これらの課題を解決するために、Goはsyncパッケージを提供しており、その中でもsync.WaitGroupは特に便利なツールです。次のセクションで、sync.WaitGroupの基本と使い方を詳しく見ていきます。

sync.WaitGroupとは

sync.WaitGroupは、Go言語のsyncパッケージに含まれる構造体で、複数のgoroutineを同期するためのツールです。これを使用することで、複数の並行処理がすべて完了するのを待つことが容易になります。

WaitGroupの主な役割

WaitGroupの主な役割は以下の通りです：

カウントの管理：実行中のgoroutineの数をカウントします。
待機の実現：すべてのgoroutineが完了するまで、処理を待機します。
同期の簡易化：手動でロックやアンロックを操作する必要がなく、安全に並行処理を管理できます。

WaitGroupの基本的な使い方

以下はWaitGroupを使った基本的な例です。

package main

import (
    "fmt"
    "sync"
)

func worker(id int, wg *sync.WaitGroup) {
    defer wg.Done() // 処理完了を通知
    fmt.Printf("Worker %d starting\n", id)
    // 実行するタスク
    fmt.Printf("Worker %d done\n", id)
}

func main() {
    var wg sync.WaitGroup
    for i := 1; i <= 3; i++ {
        wg.Add(1) // goroutineを追加
        go worker(i, &wg)
    }
    wg.Wait() // すべてのgoroutineの完了を待つ
    fmt.Println("All workers are done")
}

コードの流れ

wg.Add(1)でカウンタをインクリメント。
各goroutineでタスクを実行し、終了時にwg.Done()を呼び出してカウンタをデクリメント。
メインスレッドでwg.Wait()を呼び出し、すべてのgoroutineが完了するのを待機。

WaitGroupの特徴

スレッドセーフ：内部で排他制御が行われており、競合状態を回避できます。
柔軟な設計：任意の数のgoroutineに対応可能。

注意点

AddとDoneの呼び出し数が一致していないと、Waitが永遠に待機する可能性があります。
ポインタで渡す必要があるため、間違った値渡しをしないよう注意が必要です。

次のセクションでは、WaitGroupを使った同期の基本的な流れをより詳細に解説します。

WaitGroupを使った同期の基本的な流れ

sync.WaitGroupを使った同期処理は、次のステップで進行します。この流れを正確に理解することで、複数のgoroutineを効率よく管理することができます。

基本的な手順

WaitGroupを初期化
必要なWaitGroupインスタンスを作成します。通常はローカル変数として宣言します。

   var wg sync.WaitGroup

カウントの追加
Addメソッドを使用して、実行予定のgoroutineの数を追加します。

   wg.Add(1) // カウントを1増やす

goroutineを起動
並行処理を行うgoroutineを起動します。この際、WaitGroupをポインタとして渡します。

   go func(wg *sync.WaitGroup) {
       defer wg.Done() // 完了時にカウントをデクリメント
       // タスクの処理
   }(&wg)

カウントの完了通知
各goroutineでタスク終了時にDoneメソッドを呼び出し、カウントを減らします。

   wg.Done()

すべてのタスクの完了を待機
メインスレッドはWaitメソッドを呼び出して、すべてのgoroutineが完了するのを待ちます。

   wg.Wait()

サンプルコード

以下は基本的な流れを示したサンプルコードです。

package main

import (
    "fmt"
    "sync"
)

func task(id int, wg *sync.WaitGroup) {
    defer wg.Done() // タスク完了を通知
    fmt.Printf("Task %d is running\n", id)
    // ここに処理を記述
    fmt.Printf("Task %d is done\n", id)
}

func main() {
    var wg sync.WaitGroup
    numTasks := 5

    for i := 1; i <= numTasks; i++ {
        wg.Add(1) // タスク分カウントを追加
        go task(i, &wg)
    }

    wg.Wait() // すべてのタスクが完了するまで待機
    fmt.Println("All tasks are completed.")
}

コード解説

wg.Add(1)でgoroutineを開始するたびにカウントを増やします。
各goroutine内でdefer wg.Done()を使用して、タスク完了時にカウントを減らします。
メインスレッドはwg.Wait()を呼び出し、すべてのgoroutineが完了するのを待機します。

適用例

並列ダウンロード：複数のファイルを同時にダウンロードするプログラム。
データ処理：データセットを分割して並行して処理するシステム。
タスク分割：並列タスクの進捗を管理しながら効率的に処理を進める。

この手法により、簡潔なコードで安全かつ効率的な並行処理が実現できます。次のセクションでは、WaitGroupを使用した具体的なテスト手法を解説します。

WaitGroupを用いた並行処理のテスト

sync.WaitGroupを活用することで、Goの並行処理のテストを効率的に行うことが可能です。このセクションでは、WaitGroupを用いて並行処理をテストする基本的な手法を説明し、コード例を示します。

並行処理のテストの課題

並行処理のテストでは、以下のような課題が発生します：

goroutineの完了タイミングが不確定：タスクがいつ終了するか予測できないため、同期が重要。
競合状態の検出：複数のgoroutineが同時に共有リソースにアクセスする場合の問題。
再現性：並行処理の挙動が毎回異なる場合、テストの信頼性が損なわれる。

WaitGroupを使用すると、これらの課題に対処しながらテストを構築できます。

基本的なテストコード例

以下の例は、WaitGroupを使って並行処理が正しく動作するかをテストする方法を示しています。

package main

import (
    "sync"
    "testing"
)

func TestParallelProcessing(t *testing.T) {
    var wg sync.WaitGroup
    results := make([]int, 5) // 結果を格納するスライス

    for i := 0; i < 5; i++ {
        wg.Add(1)
        go func(index int) {
            defer wg.Done()
            results[index] = index * 2 // ダミーの処理
        }(i)
    }

    wg.Wait()

    // 結果の検証
    for i, result := range results {
        expected := i * 2
        if result != expected {
            t.Errorf("Expected %d, but got %d", expected, result)
        }
    }
}

コードのポイント

共有データの準備：resultsスライスに計算結果を格納します。
goroutineの管理：wg.Addでカウントを増やし、defer wg.Doneでタスク終了を通知します。
検証処理：resultsを確認し、期待値と比較します。

競合状態のテスト

競合状態が発生するかを検証するテスト例も重要です。以下に競合状態を検出するためのサンプルを示します。

package main

import (
    "sync"
    "sync/atomic"
    "testing"
)

func TestRaceCondition(t *testing.T) {
    var counter int32
    var wg sync.WaitGroup

    for i := 0; i < 100; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            atomic.AddInt32(&counter, 1) // 競合を防ぐためatomic操作
        }()
    }

    wg.Wait()

    if counter != 100 {
        t.Errorf("Expected 100, but got %d", counter)
    }
}

コードのポイント

atomicパッケージの利用：atomic.AddInt32を使用して競合状態を防ぎます。
並行処理の負荷：100回のgoroutineを生成して意図的に負荷をかけます。
結果の確認：期待される値と実際の値を比較し、不一致をエラーとして報告します。

注意点

共有リソースへのアクセス：スレッドセーフな方法（atomicやsync.Mutex）を用いる。
goroutineの確実な終了：テストが終了する前にすべてのgoroutineが完了するようにする。

このようにして、WaitGroupを利用することで、並行処理の正確性や競合状態を簡潔にテストできます。次のセクションでは、エラー処理とWaitGroupの組み合わせについて詳しく解説します。

エラー処理とWaitGroup

並行処理を行う際、エラーが発生した場合の対応は非常に重要です。sync.WaitGroupを活用することで、並行処理中に発生したエラーを収集し、適切に管理する方法を実装できます。

エラーの管理方法

Go言語では、複数のgoroutineからエラーを収集するために以下のアプローチを採用します：

チャネルを使用する：エラーを安全に収集するためにチャネルを利用します。
スライスとミューテックスを使用する：エラーをスライスに格納し、アクセスをミューテックスで保護します。
コンテキストを活用する：contextパッケージでキャンセル機能を組み合わせ、エラー発生時に並行処理を中止します。

チャネルを用いたエラー処理の例

以下の例は、チャネルを使用してエラーを収集する方法を示します。

package main

import (
    "errors"
    "fmt"
    "sync"
)

func worker(id int, wg *sync.WaitGroup, errChan chan<- error) {
    defer wg.Done()
    if id%2 == 0 { // 偶数IDのタスクでエラーを発生させる
        errChan <- fmt.Errorf("error in worker %d", id)
    } else {
        fmt.Printf("Worker %d completed successfully\n", id)
    }
}

func main() {
    var wg sync.WaitGroup
    errChan := make(chan error, 10) // エラーを格納するチャネル

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

    wg.Wait()
    close(errChan) // チャネルを閉じる

    for err := range errChan { // チャネルからエラーを取り出す
        if err != nil {
            fmt.Println("Error:", err)
        }
    }

    fmt.Println("All workers completed with error handling")
}

コード解説

エラー送信：goroutine内で発生したエラーをerrChanに送信。
チャネルの閉じるタイミング：すべてのタスクが完了した後、チャネルを閉じる。
エラーの収集：rangeを使用してチャネルからエラーを取り出します。

スライスとミューテックスを使ったエラー管理の例

以下は、エラーをスライスに収集し、ミューテックスで保護する方法です。

package main

import (
    "fmt"
    "sync"
)

func worker(id int, wg *sync.WaitGroup, errors *[]error, mu *sync.Mutex) {
    defer wg.Done()
    if id%2 == 0 {
        mu.Lock()
        *errors = append(*errors, fmt.Errorf("error in worker %d", id))
        mu.Unlock()
    } else {
        fmt.Printf("Worker %d completed successfully\n", id)
    }
}

func main() {
    var wg sync.WaitGroup
    var mu sync.Mutex
    var errors []error

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

    wg.Wait()

    if len(errors) > 0 {
        fmt.Println("Errors occurred:")
        for _, err := range errors {
            fmt.Println(err)
        }
    } else {
        fmt.Println("All workers completed successfully")
    }
}

コード解説

エラーの保護：スライスへのアクセスをミューテックスで同期。
スライスの活用：すべてのエラーを1つのスライスに収集。
結果の出力：エラーが存在する場合のみ出力。

注意点

チャネルのバッファサイズを適切に設定し、送信ブロックを防ぐ。
スライスの利用時は必ずミューテックスで競合を防ぐ。
大規模な並行処理ではcontextを活用して効率的にキャンセル処理を行う。

これらの方法を用いることで、WaitGroupとエラー処理を効果的に組み合わせ、並行処理の信頼性を向上させることができます。次のセクションでは、WaitGroupの誤用を防ぐための注意点を解説します。

WaitGroupの誤用を避けるための注意点

sync.WaitGroupはGo言語で非常に便利な同期ツールですが、使い方を誤ると予期せぬバグやデッドロックを引き起こす可能性があります。このセクションでは、WaitGroupの典型的な誤用とその対策を解説します。

1. AddとDoneの不一致

問題

Addでカウントを増やした数と、Doneで減らした数が一致しない場合、Waitが永遠にブロックされるか、パニックが発生します。

例

package main

import (
    "sync"
)

func main() {
    var wg sync.WaitGroup
    wg.Add(1)
    // Doneを呼び忘れる
    wg.Wait() // 永遠に待機
}

対策

Addを呼ぶ際は、必ず対応するDoneを確実に呼ぶようにする。
defer wg.Done()を使用して、goroutine内で確実にDoneが呼び出されるようにする。

修正例

go func() {
    defer wg.Done()
    // タスク処理
}()

2. WaitGroupを値渡しする

問題

WaitGroupは内部的にポインタで管理されているため、値渡しを行うとカウントが正しく管理されません。

例

func worker(wg sync.WaitGroup) {
    defer wg.Done() // このDoneは無効
}

func main() {
    var wg sync.WaitGroup
    wg.Add(1)
    go worker(wg) // 値渡し
    wg.Wait()
}

対策

常にポインタで渡すようにします。

修正例

func worker(wg *sync.WaitGroup) {
    defer wg.Done()
}

func main() {
    var wg sync.WaitGroup
    wg.Add(1)
    go worker(&wg) // ポインタ渡し
    wg.Wait()
}

3. Doneを呼ぶ前にgoroutineが終了

問題

エラーや予期しない終了でDoneが呼ばれない場合、カウントが減らずWaitがブロックされ続けます。

例

go func() {
    // 何らかのエラーで途中終了
    return
    wg.Done() // 呼ばれない
}()

対策

必ずdeferを使用して、goroutineが終了する際にDoneを呼び出す。
エラー処理を適切に実装し、途中終了を防ぐ。

修正例

go func() {
    defer wg.Done()
    // タスク処理
}()

4. カウントを動的に変更する

問題

Addでカウントを動的に変更する場合、goroutineの実行タイミングによって予測できない動作が発生します。

例

wg.Add(1)
go func() {
    wg.Add(1) // 実行タイミングに依存する
    wg.Done()
}()
wg.Done()

対策

Addの呼び出しは、goroutineを起動する前にまとめて行う。

修正例

wg.Add(2) // 先にカウントを追加
go func() {
    defer wg.Done()
    // タスク処理
}()

5. 複数のWaitを呼び出す

問題

1つのWaitGroupで複数のWaitを同時に呼び出すと、不整合が発生します。

対策

1つのWaitGroupは1つのWaitに対してのみ使用する。
必要に応じて別のWaitGroupを用意する。

まとめ

WaitGroupは簡潔で強力な同期ツールですが、正しく使用しなければ期待通りの動作をしない可能性があります。本セクションで紹介した誤用と対策を参考にして、コードの信頼性を向上させましょう。次のセクションでは、WaitGroupを用いた大量の並行処理の応用例を紹介します。

応用例：大量の並行処理を管理する

sync.WaitGroupは、小規模な並行処理だけでなく、大量のgoroutineを効率的に管理する場合にも非常に有用です。このセクションでは、実際のプロジェクトで役立つ、WaitGroupを使った大量の並行処理の応用例を紹介します。

大量のデータ処理

膨大なデータセットを並行して処理し、効率を最大化する例です。

コード例

以下は、1000件のデータを10のgoroutineで並列処理する例です。

package main

import (
    "fmt"
    "sync"
)

func processBatch(batch []int, wg *sync.WaitGroup) {
    defer wg.Done()
    for _, item := range batch {
        // データ処理のシミュレーション
        fmt.Printf("Processing item: %d\n", item)
    }
}

func main() {
    var wg sync.WaitGroup
    data := make([]int, 1000)
    for i := 0; i < 1000; i++ {
        data[i] = i
    }

    batchSize := 100
    for i := 0; i < len(data); i += batchSize {
        end := i + batchSize
        if end > len(data) {
            end = len(data)
        }
        wg.Add(1)
        go processBatch(data[i:end], &wg)
    }

    wg.Wait()
    fmt.Println("All data processed.")
}

コード解説

バッチ分割：データを複数のバッチに分割。
goroutineの起動：各バッチをgoroutineで並行処理。
同期管理：WaitGroupですべてのバッチ処理が完了するのを待機。

大量のHTTPリクエスト処理

複数のAPIエンドポイントに対して並列にリクエストを送信し、結果を収集する例です。

コード例

以下は、10個のAPIエンドポイントに並列でリクエストを送信する例です。

package main

import (
    "fmt"
    "net/http"
    "sync"
)

func fetchURL(url string, wg *sync.WaitGroup, results chan<- string) {
    defer wg.Done()
    resp, err := http.Get(url)
    if err != nil {
        results <- fmt.Sprintf("Error fetching %s: %v", url, err)
        return
    }
    defer resp.Body.Close()
    results <- fmt.Sprintf("Success: %s", url)
}

func main() {
    var wg sync.WaitGroup
    urls := []string{
        "https://example.com",
        "https://golang.org",
        "https://github.com",
        // 他のURLを追加
    }
    results := make(chan string, len(urls))

    for _, url := range urls {
        wg.Add(1)
        go fetchURL(url, &wg, results)
    }

    wg.Wait()
    close(results)

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

コード解説

チャネルの使用：各リクエストの結果をチャネルに収集。
エラー管理：リクエスト失敗時のエラーメッセージを格納。
結果の出力：すべてのリクエスト結果を処理後に出力。

Workerパターンの活用

大量のタスクを固定数のgoroutineで処理する、効率的なWorkerパターンの例です。

コード例

以下は、5つのWorkerを使って20個のタスクを処理する例です。

package main

import (
    "fmt"
    "sync"
)

func worker(id int, tasks <-chan int, wg *sync.WaitGroup) {
    defer wg.Done()
    for task := range tasks {
        fmt.Printf("Worker %d processing task %d\n", id, task)
    }
}

func main() {
    var wg sync.WaitGroup
    tasks := make(chan int, 20)

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

    for i := 1; i <= 20; i++ {
        tasks <- i
    }
    close(tasks)

    wg.Wait()
    fmt.Println("All tasks completed.")
}

コード解説

タスクチャネル：タスクをキューとしてチャネルに格納。
固定数のWorker：一定数のgoroutineでタスクを分担処理。
チャネルのクローズ：すべてのタスクを送信した後、チャネルを閉じる。

注意点

リソースの制限：大量のgoroutineがリソースを圧迫しないよう、必要に応じてWorkerパターンを採用。
エラー管理：エラーが発生した場合でも、全タスクが正しく終了するような仕組みを組み込む。

これらの応用例を活用することで、実際のプロジェクトでスケーラブルかつ効率的な並行処理を実現できます。次のセクションでは、学習を深めるための演習問題を提供します。

演習問題：WaitGroupを使った簡単なタスクの実装

sync.WaitGroupの理解を深めるために、以下の演習問題に挑戦してください。それぞれの問題は基本から応用まで幅広くカバーしています。

問題1: 複数タスクの同期

概要
5つのgoroutineを起動し、それぞれ異なるIDを表示するプログラムを作成してください。すべてのgoroutineが終了した後に「All tasks are done」と表示されるようにします。

期待される出力例

Task 1 is running
Task 2 is running
Task 3 is running
Task 4 is running
Task 5 is running
All tasks are done

ヒント

sync.WaitGroupを使い、タスク完了の同期をとりましょう。
タスクごとにwg.Addとwg.Doneを使用します。

問題2: データ処理の並列化

概要
整数のスライスを与え、それぞれの要素を2倍にする処理をgoroutineを使って並列に実行してください。結果は元のスライスに反映させます。

期待される出力例
入力スライス: [1, 2, 3, 4, 5]
出力スライス: [2, 4, 6, 8, 10]

ヒント

スライスの各要素に対して1つのgoroutineを起動します。
スライスへの書き込みが安全に行われるように注意してください。

問題3: エラー収集

概要
5つのgoroutineを起動し、偶数IDのタスクでエラーを発生させます。エラーをチャネルで収集し、すべてのエラーを出力してください。

期待される出力例

Worker 1 completed successfully
Error in worker 2
Worker 3 completed successfully
Error in worker 4
Worker 5 completed successfully
Collected errors:
- Error in worker 2
- Error in worker 4

ヒント

チャネルを用いてエラーを安全に収集します。
すべてのgoroutineが終了した後、チャネルを閉じてエラーを出力します。

問題4: Workerパターンの実装

概要
20個のタスクを処理するプログラムを作成し、5つのWorkerを使用して並列に処理を行います。それぞれのWorkerがどのタスクを処理したかを表示してください。

期待される出力例

Worker 1 processing task 1
Worker 2 processing task 2
Worker 3 processing task 3
...
Worker 5 processing task 5
Worker 1 processing task 6
...
All tasks are completed.

ヒント

タスクはチャネルを使用してWorkerに割り当てます。
WaitGroupを使ってすべてのWorkerが終了するのを待ちます。

問題5: タイムアウト付きの同期

概要
3つのタスクを起動し、それぞれにランダムな時間がかかる処理をさせます。全タスクの完了を待つが、タイムアウトが発生した場合は「Timeout occurred」と表示してください。

期待される出力例
タイムアウトしなかった場合:

Task 1 is done
Task 2 is done
Task 3 is done
All tasks are completed.

タイムアウトした場合:

Timeout occurred

ヒント

context.WithTimeoutを使用してタイムアウトを設定します。
タスクが終了したかタイムアウトしたかを確認します。

演習の進め方

各問題の要件に基づいてコードを作成してください。
作成したコードをテストし、期待通りの動作を確認してください。
必要に応じて、Goの公式ドキュメントやsyncパッケージの資料を参照してください。

これらの演習を通じて、sync.WaitGroupの使用方法や並行処理の実装に関するスキルを実践的に身に付けることができます。次のセクションでは、本記事のまとめを行います。

まとめ

本記事では、Go言語のsync.WaitGroupを使った並行処理のテストと同期方法について解説しました。WaitGroupの基本的な使用法からエラー処理の実装、大量の並行処理の応用例、そして演習問題まで、実践的な内容を網羅しました。

並行処理を正しく管理することで、パフォーマンスの向上だけでなく、プログラムの信頼性を大幅に向上させることができます。特に以下のポイントを押さえることが重要です：

WaitGroupを用いた正確な同期。
チャネルやミューテックスを活用したエラーの安全な管理。
Workerパターンやタイムアウトを組み合わせた柔軟な設計。

これらの知識を活かして、効率的で堅牢なGoプログラムを構築していきましょう。

この記事を書いた人

佐藤健司

実務の現場で詰まりがちなポイントを地図にするITブログ「IT trip」を運営。Windows／Office（Teams・Excel）からSQL、サーバ運用、ガジェットまで、再現性のある手順と“なぜそうなるか”を丁寧に解説します。読んだらすぐ試せること、そして迷った人の次の一歩が見えることを大切にしています。

Go言語のsync.WaitGroupで並行処理を効率的にテストする方法

Go言語の並行処理の基礎

goroutineとは

チャネルと並行処理

並行処理の課題

sync.WaitGroupとは

WaitGroupの主な役割

WaitGroupの基本的な使い方

コードの流れ

WaitGroupの特徴

注意点

WaitGroupを使った同期の基本的な流れ

基本的な手順

サンプルコード

コード解説

適用例

WaitGroupを用いた並行処理のテスト

並行処理のテストの課題

基本的なテストコード例

コードのポイント

競合状態のテスト

コードのポイント

注意点

エラー処理とWaitGroup

エラーの管理方法

チャネルを用いたエラー処理の例

コード解説

スライスとミューテックスを使ったエラー管理の例

コード解説

注意点

WaitGroupの誤用を避けるための注意点

1. AddとDoneの不一致

問題

例

対策

修正例

2. WaitGroupを値渡しする

問題

例

対策

修正例

3. Doneを呼ぶ前にgoroutineが終了

問題

例

対策

修正例

4. カウントを動的に変更する

問題

例

対策

修正例

5. 複数のWaitを呼び出す

問題

対策

まとめ

応用例：大量の並行処理を管理する

大量のデータ処理

コード例

コード解説

大量のHTTPリクエスト処理

コード例

コード解説

Workerパターンの活用

コード例

コード解説

注意点

演習問題：WaitGroupを使った簡単なタスクの実装

問題1: 複数タスクの同期

問題2: データ処理の並列化

問題3: エラー収集

問題4: Workerパターンの実装

問題5: タイムアウト付きの同期

演習の進め方

まとめ

この記事を書いた人

関連記事

コメント

コメントする コメントをキャンセル

コメントするコメントをキャンセル