Goで学ぶ並行処理と並列処理の実務ベストプラクティス

2026年5月9日

お得なお知らせ

スポンサードリンク

AI時代のキャリア構築

プログラミング学習、今日から動き出す

「何から始めるか」で止まっている人こそ、無料説明会や本で自分に合うルートを30分で確定できます。

Enjoy Tech!｜月額制でWeb系に強い▶ (Kindle本)ＩＴエンジニアの転職学｜後悔しないキャリア戦略▶

▶ AIコーディング環境なら実践Claude Code入門（Amazon）が実務で即使える入門書です。Amazonベストセラーにも選ばれていますよ。

Contents

1 並行処理と並列処理の違い
- 1.1 概念整理
- 1.2 実務上のポイント
2 goroutine の基礎
- 2.1 1. goroutine の作成
- 2.2 2. スタックサイズの自動拡張
3 channel と select の活用法
4 同期・キャンセル機構
- 4.1 1. sync.WaitGroup と sync.Mutex
- 4.2 2. context パッケージでキャンセルとデッドライン管理
5 代表的な並行パターン
6 Go 1.22 の新機能と実務ベストプラクティス
7 参考リンク

スポンサードリンク

並行処理と並列処理の違い

概念整理

用語	定義	主な利用シーン
Concurrency（並行処理）	複数タスクを設計上同時に進めること。スレッド数が足りなくても、実装は単一スレッドで動くことがある。	I/O 待ちやユーザー入力の同時受付
Parallelism（並列処理）	複数タスクを物理的に同時に実行すること。CPU コアが複数あれば、OS スレッドがそれぞれ別コアで走る。	CPU バウンドな計算・画像加工

Go のランタイムは M:N スケジューラ（G = goroutine, M = OS スレッド, P = 実行単位）を採用しており、並行に書いたコードは実行時に自動で並列にスケジュールされます。

CPU: 4 コア
goroutine A,B,C が同時に走る → 並行設計
OS スレッドが 2 本だけの場合、A と B は同時に実行され C は待機 → 実際の並列度は 2

CPU: 4 コア

goroutine A,B,C が同時に走る → 並行設計

OS スレッドが 2 本だけの場合、A と B は同時に実行され C は待機 → 実際の並列度は 2

Qiita 記事「【Go 入門】 Goで並列処理を体感してみよう」でも同様の図解が掲載されています。
https://qiita.com/manabito76/items/448b77e2fc557016eadf

実務上のポイント

タスク分割は並行設計で考える（「何を同時にやるか」）。
CPU 数に応じた runtime.GOMAXPROCS の設定だけで、ランタイムが最適な並列実行へ切り替わります。

goroutine の基礎

1. goroutine の作成

package main

import (
    &quot;fmt&quot;
    &quot;time&quot;
)

func hello(id int) {
    fmt.Printf(&quot;goroutine %d start\n&quot;, id)
    time.Sleep(500 * time.Millisecond)
    fmt.Printf(&quot;goroutine %d end\n&quot;, id)
}

func main() {
    for i := 1; i &lt;= 5; i++ {
        go hello(i) // ← ここで goroutine を生成
    }
    // メインがすぐに終了しないように待機（テスト用）
    time.Sleep(2 * time.Second)
}

package main

import (

"fmt"

"time"

)

func hello(id int) {

fmt.Printf("goroutine %d start\n", id)

time.Sleep(500 * time.Millisecond)

fmt.Printf("goroutine %d end\n", id)

}

func main() {

for i := 1; i <= 5; i++ {

go hello(i) // ← ここで goroutine を生成

}

// メインがすぐに終了しないように待機（テスト用）

time.Sleep(2 * time.Second)

}

go キーワードひとつで 非同期 に実行でき、スタックサイズやスケジューリングはランタイムが自動管理します。

2. スタックサイズの自動拡張

項目	内容
初期サイズ	約 2 KB（Go 1.22 では 2 KB）
最大上限	1 GB（公式ドキュメント: https://go.dev/ref/spec#Size_and_alignment_of_variables に記載）
拡張方式	必要に応じて倍増し、不要になれば縮小される（「スプリット」アルゴリズム）

func deepRecursion(n int) {
    if n == 0 {
        return
    }
    fmt.Println(&quot;depth:&quot;, n)
    deepRecursion(n - 1)
}

// 実行例: deepRecursion(10000) を goroutine 内で呼び出すと自動的に拡張される

func deepRecursion(n int) {

if n == 0 {

return

}

fmt.Println("depth:", n)

deepRecursion(n - 1)

}

// 実行例: deepRecursion(10000) を goroutine 内で呼び出すと自動的に拡張される

ポイント: 開発者がスタックサイズを意識する必要はほぼありません。メモリ使用量が気になる場合は runtime.Stack で実行時のスタック情報を取得できます。

channel と select の活用法

1. バッファ有無（unbuffered vs buffered）

// unbuffered (バッファなし)
ch := make(chan int) // サイズ 0

go func() {
    ch &lt;- 42 // 受信側が待つまでブロック
}()

fmt.Println(&lt;-ch) // ← ここで受信し、送信が完了

// unbuffered (バッファなし)

ch := make(chan int) // サイズ 0

go func() {

ch <- 42 // 受信側が待つまでブロック

}()

fmt.Println(<-ch) // ← ここで受信し、送信が完了

// buffered (バッファあり)
bufCh := make(chan string, 3) // バッファサイズ 3

bufCh &lt;- &quot;a&quot;
bufCh &lt;- &quot;b&quot;
// まだ受信しなくてもブロックされない
fmt.Println(&lt;-bufCh) // a

// buffered (バッファあり)

bufCh := make(chan string, 3) // バッファサイズ 3

bufCh <- "a"

bufCh <- "b"

// まだ受信しなくてもブロックされない

fmt.Println(<-bufCh) // a

unbuffered は「通信相手が揃うまで待つ」ことでレースコンディションを防止。
buffered はスループット向上とバックプレッシャー制御に有効。

2. 方向限定チャネル

func producer(out chan&lt;- int) {
    for i := 0; i &lt; 5; i++ {
        out &lt;- i
    }
    close(out)
}

func consumer(in &lt;-chan int) {
    for v := range in {
        fmt.Println(v)
    }
}

func producer(out chan<- int) {

for i := 0; i < 5; i++ {

out <- i

}

close(out)

}

func consumer(in <-chan int) {

for v := range in {

fmt.Println(v)

}

chan<-（送信専用）と <-chan（受信専用）は API の安全性 を高め、誤ったデータフローをコンパイル時に検出できます。

3. select 文でマルチチャネル待ち合わせ & タイムアウト

func fetch(ctx context.Context, url string) (string, error) {
    resultCh := make(chan string, 1)

    go func() {
        // 本来は http.Get 等の実装
        time.Sleep(2 * time.Second)
        select {
        case &lt;-ctx.Done():
            return // キャンセルされたら何もしない
        default:
            resultCh &lt;- &quot;OK&quot;
        }
    }()

    select {
    case &lt;-ctx.Done():
        return &quot;&quot;, ctx.Err()
    case res := &lt;-resultCh:
        return res, nil
    case &lt;-time.After(1 * time.Second):
        return &quot;&quot;, fmt.Errorf(&quot;timeout&quot;)
    }
}

func fetch(ctx context.Context, url string) (string, error) {

resultCh := make(chan string, 1)

go func() {

// 本来は http.Get 等の実装

time.Sleep(2 * time.Second)

select {

case <-ctx.Done():

return // キャンセルされたら何もしない

default:

resultCh <- "OK"

}

}()

select {

case <-ctx.Done():

return "", ctx.Err()

case res := <-resultCh:

return res, nil

case <-time.After(1 * time.Second):

return "", fmt.Errorf("timeout")

}

select は 複数の待ち と タイムアウト/キャンセル をシンプルに記述でき、デフォルトケース (default) の有無で「ノンブロッキング」かどうかを制御できます。

同期・キャンセル機構

1. sync.WaitGroup と sync.Mutex

var wg sync.WaitGroup
for i := 0; i &lt; 3; i++ {
    wg.Add(1)
    go func(id int) {
        defer wg.Done()
        fmt.Printf(&quot;worker %d start\n&quot;, id)
        time.Sleep(time.Duration(id) * time.Second)
        fmt.Printf(&quot;worker %d done\n&quot;, id)
    }(i)
}
wg.Wait() // 全ワーカーが終了するまで待つ

var wg sync.WaitGroup

for i := 0; i < 3; i++ {

wg.Add(1)

go func(id int) {

defer wg.Done()

fmt.Printf("worker %d start\n", id)

time.Sleep(time.Duration(id) * time.Second)

fmt.Printf("worker %d done\n", id)

}(i)

}

wg.Wait() // 全ワーカーが終了するまで待つ

var (
    mu   sync.Mutex
    data = make(map[string]int)
)

func inc(key string) {
    mu.Lock()
    defer mu.Unlock()
    data[key]++
}

var (

mu sync.Mutex

data = make(map[string]int)

)

func inc(key string) {

mu.Lock()

defer mu.Unlock()

data[key]++

}

WaitGroup は タスク完了の集合的監視、Mutex は 共有リソースへの排他制御 を提供します。

2. context パッケージでキャンセルとデッドライン管理

func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
    defer cancel()

    go func(ctx context.Context) {
        for {
            select {
            case &lt;-ctx.Done():
                fmt.Println(&quot;goroutine stopped:&quot;, ctx.Err())
                return
            default:
                time.Sleep(500 * time.Millisecond)
                fmt.Print(&quot;.&quot;)
            }
        }
    }(ctx)

    &lt;-ctx.Done() // メインはタイムアウトまで待機
}

func main() {

ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)

defer cancel()

go func(ctx context.Context) {

for {

select {

case <-ctx.Done():

fmt.Println("goroutine stopped:", ctx.Err())

return

default:

time.Sleep(500 * time.Millisecond)

fmt.Print(".")

}

}(ctx)

<-ctx.Done() // メインはタイムアウトまで待機

}

context.WithCancel, WithTimeout, WithDeadline は 階層的にキャンセル情報を伝搬 し、長時間走る goroutine のリーク防止に必須です。

代表的な並行パターン

1. Worker Pool（固定数ワーカー）

func worker(id int, jobs &lt;-chan int, results chan&lt;- int) {
    for j := range jobs {
        fmt.Printf(&quot;worker %d processing job %d\n&quot;, id, j)
        time.Sleep(time.Second) // 擬似処理
        results &lt;- j * 2
    }
}

func main() {
    const numWorkers = 3
    jobs := make(chan int, 10)
    results := make(chan int, 10)

    for w := 1; w &lt;= numWorkers; w++ {
        go worker(w, jobs, results)
    }

    for j := 1; j &lt;= 5; j++ {
        jobs &lt;- j
    }
    close(jobs)

    for i := 0; i &lt; 5; i++ {
        fmt.Println(&quot;result:&quot;, &lt;-results)
    }
}

func worker(id int, jobs <-chan int, results chan<- int) {

for j := range jobs {

fmt.Printf("worker %d processing job %d\n", id, j)

time.Sleep(time.Second) // 擬似処理

results <- j * 2

}

func main() {

const numWorkers = 3

jobs := make(chan int, 10)

results := make(chan int, 10)

for w := 1; w <= numWorkers; w++ {

go worker(w, jobs, results)

}

for j := 1; j <= 5; j++ {

jobs <- j

}

close(jobs)

for i := 0; i < 5; i++ {

fmt.Println("result:", <-results)

}

利点: 同時実行数を一定に保ち、CPU コア数と合わせてリソース消費の上限が予測しやすい。

2. Fan‑out / Fan‑in（分散 & 集約）

func fetch(id int) string {
    time.Sleep(time.Duration(id) * 100 * time.Millisecond)
    return fmt.Sprintf(&quot;data-%d&quot;, id)
}

func main() {
    n := 4
    out := make(chan string, n)

    for i := 0; i &lt; n; i++ {
        go func(i int) {
            out &lt;- fetch(i)
        }(i)
    }

    for i := 0; i &lt; n; i++ {
        fmt.Println(&lt;-out) // fan‑in
    }
}

func fetch(id int) string {

time.Sleep(time.Duration(id) * 100 * time.Millisecond)

return fmt.Sprintf("data-%d", id)

}

func main() {

n := 4

out := make(chan string, n)

for i := 0; i < n; i++ {

go func(i int) {

out <- fetch(i)

}(i)

}

for i := 0; i < n; i++ {

fmt.Println(<-out) // fan‑in

}

fan‑out: 複数の goroutine にタスクを分散させ、I/O 待ち時間を相殺。
fan‑in: 結果を 1 本のチャネルに集約し、呼び出し側は単一受信で完結。

3. Pipeline（ステージング）

func gen(nums ...int) &lt;-chan int {
    out := make(chan int)
    go func() {
        for _, n := range nums {
            out &lt;- n
        }
        close(out)
    }()
    return out
}

func square(in &lt;-chan int) &lt;-chan int {
    out := make(chan int)
    go func() {
        for n := range in {
            out &lt;- n * n
        }
        close(out)
    }()
    return out
}

func main() {
    nums := gen(1, 2, 3, 4)
    squares := square(nums)

    for v := range squares {
        fmt.Println(v) // 1, 4, 9, 16
    }
}

func gen(nums ...int) <-chan int {

out := make(chan int)

go func() {

for _, n := range nums {

out <- n

}

close(out)

}()

return out

}

func square(in <-chan int) <-chan int {

out := make(chan int)

go func() {

for n := range in {

out <- n * n

}

close(out)

}()

return out

}

func main() {

nums := gen(1, 2, 3, 4)

squares := square(nums)

for v := range squares {

fmt.Println(v) // 1, 4, 9, 16

}

特徴: 各ステージが独立して動作できるため、保守性とスループットが向上。
実装ポイント: ステージ間は必ずチャネルで接続し、close によって下流へ終了シグナルを伝搬させる。

Go 1.22 の新機能と実務ベストプラクティス

1. errgroup パッケージの現状（誤解の訂正）

Go 1.22 でも golang.org/x/sync/errgroup の API は変更されていません。
- 従来どおり errgroup.WithContext(ctx) が必要です。
- Group.Go のシグネチャは依然として func() error（context.Context を受け取らない）です。

import (
    &quot;context&quot;
    &quot;net/http&quot;

    &quot;golang.org/x/sync/errgroup&quot;
)

func main() {
    g, ctx := errgroup.WithContext(context.Background())

    urls := []string{&quot;a.com&quot;, &quot;b.com&quot;, &quot;c.com&quot;}
    for _, u := range urls {
        u := u // ループ変数のスコープ対策
        g.Go(func() error { // ← 引数はなし
            req, err := http.NewRequestWithContext(ctx, http.MethodGet, &quot;https://&quot;+u, nil)
            if err != nil {
                return err
            }
            resp, err := http.DefaultClient.Do(req)
            if err != nil {
                return err
            }
            defer resp.Body.Close()
            // ...処理...
            return nil
        })
    }

    if err := g.Wait(); err != nil {
        fmt.Println(&quot;failed:&quot;, err)
    }
}

import (

"context"

"net/http"

"golang.org/x/sync/errgroup"

)

func main() {

g, ctx := errgroup.WithContext(context.Background())

urls := []string{"a.com", "b.com", "c.com"}

for _, u := range urls {

u := u // ループ変数のスコープ対策

g.Go(func() error { // ← 引数はなし

req, err := http.NewRequestWithContext(ctx, http.MethodGet, "https://"+u, nil)

if err != nil {

return err

}

resp, err := http.DefaultClient.Do(req)

if err != nil {

return err

}

defer resp.Body.Close()

// ...処理...

return nil

})

}

if err := g.Wait(); err != nil {

fmt.Println("failed:", err)

}

errgroup.WithContext が返す 子コンテキスト (ctx) は、どの goroutine でもキャンセルやタイムアウトを共有できる点が便利です。
今後のバージョンでシグネチャ変更があればリリースノートに明示されますので、常に公式ドキュメント（https://pkg.go.dev/golang.org/x/sync/errgroup）を参照してください。

2. デッドロック・リーク回避チェックリスト

項目	確認ポイント	推奨ツール
Mutex の取得順序	複数の `Lock` が同一順序で呼ばれているか	静的解析 (`go vet -run=atomic`)
channel の対称性	送信側と受信側が必ず対になるか（バッファサイズ・クローズ）	`staticcheck`
goroutine の終了パス	全ての goroutine が `ctx.Done()` または `wg.Done()` に到達するか	カスタムテスト (`TestLeak`)
タイムアウト設定	長時間ブロックしうる操作に `context.WithTimeout` を使用しているか	コードレビュー
errgroup/WaitGroup のカウント漏れ	`Add` と `Done` が 1:1 になるか	`-race` オプションで実行

3. 実務向けサンプルコードの取得

GitHub リポジトリ（Go 1.22 対応）
https://github.com/manabito76/go-concurrency-samples

リポジトリには以下が同梱されています。

ディレクトリ	内容
`example/workerpool`	Worker Pool の実装とベンチマーク
`example/pipeline`	3 ステージ Pipeline とテスト
`example/fanoutin`	Fan‑out / Fan‑in パターン
`example/errgroup`	正しい `errgroup.WithContext` 使用例

git clone https://github.com/manabito76/go-concurrency-samples.git
cd go-concurrency-samples/example/workerpool
go test -bench=.

git clone https://github.com/manabito76/go-concurrency-samples.git

cd go-concurrency-samples/example/workerpool

go test -bench=.

4. まとめのベストプラクティス

設計は並行性で考える → タスク分割・データフローを明確化。
実装は標準ライブラリだけで完結 → goroutine, channel, select, sync, context, errgroup を組み合わせる。
リソース制御はコンテキストと WaitGroup で一元管理 → キャンセル・タイムアウトが漏れないようにする。
テストとベンチマークは必須 → go test -race, -bench でデッドロックやリークを早期検出。
公式ドキュメントとリリースノートを定期的にチェック → API 変更（例: errgroup のシグネチャ）への対応が楽になる。

参考リンク

Go 言語仕様 – スタックサイズ上限: https://go.dev/ref/spec#Size_and_alignment_of_variables
runtime パッケージ – GOMAXPROCS: https://pkg.go.dev/runtime#GOMAXPROCS
sync/errgroup パッケージ: https://pkg.go.dev/golang.org/x/sync/errgroup
context パッケージ: https://pkg.go.dev/context

以上が Go 1.22 に合わせて改訂した並行処理入門と実務パターンです。ぜひローカル環境でサンプルを動かし、実際のプロジェクトへ応用してみてください。

スポンサードリンク

お得なお知らせ

スポンサードリンク

AI時代のキャリア構築

プログラミング学習、今日から動き出す

「何から始めるか」で止まっている人こそ、無料説明会や本で自分に合うルートを30分で確定できます。

Enjoy Tech!｜月額制でWeb系に強い▶ (Kindle本)ＩＴエンジニアの転職学｜後悔しないキャリア戦略▶

▶ AIコーディング環境なら実践Claude Code入門（Amazon）が実務で即使える入門書です。Amazonベストセラーにも選ばれていますよ。

-Go言語

comment コメントをキャンセル

: Go言語

Docker と WSL2/macOSで Go 開発環境を構築する完全ガイド

本記事では Windows (WSL2)・macOS・Linux 向けに Docker Desktop のインストール手順から、golang:slim と Alpine を用いたマルチステージビルド、VS Code devcontainer 設定、air によるホットリロード、Delve デバッグまでを一連のフローとして紹介します。

: Go言語

Go言語でマイクロサービス比較 – フレームワーク選びと導入ポイント

Go言語のマイクロサービスフレームワークを機能・拡張性・コミュニティ活性度で比較し、導入すべき選択肢と運用上の注意点をまとめました。

: Go言語

Go 1.22で始めるRESTful API開発ガイド：環境構築・プロジェクト設計・Router比較

Go 1.22環境でのAPI開発に必要なセットアップからコード設計、Router選択、テスト・デプロイまでを一括で学べる実践ガイドです。

: Go言語

Go 1.22 のプロジェクト構成と最小サイズ Docker イメージ作成ガイド

Go 1.22 プロジェクトのベストプラクティスと、5 MB 未満の最小 Docker イメージ構築手順をまとめました。

: Go言語

Go 1.26 リリースと実験的 Goroutine Leak プロファイル完全ガイド

Go 1.26 のリリース概要、実験的 Goroutine Leak Profiles の使い方、nil の内部変更と標準ライブラリの重要更新をわかりやすく解説します。

GCP無料トライアルと$300クレジット活用完全ガイド

Notion API 2026年最新仕様と公式連携・自動化活用ガイド

Goで学ぶ並行処理と並列処理の実務ベストプラクティス

並行処理と並列処理の違い

概念整理

実務上のポイント

goroutine の基礎

1. goroutine の作成

2. スタックサイズの自動拡張

channel と select の活用法

1. バッファ有無（unbuffered vs buffered）

2. 方向限定チャネル

3. select 文でマルチチャネル待ち合わせ & タイムアウト

同期・キャンセル機構

1. sync.WaitGroup と sync.Mutex

2. context パッケージでキャンセルとデッドライン管理

代表的な並行パターン

1. Worker Pool（固定数ワーカー）

2. Fan‑out / Fan‑in（分散 & 集約）

3. Pipeline（ステージング）

Go 1.22 の新機能と実務ベストプラクティス

1. errgroup パッケージの現状（誤解の訂正）

2. デッドロック・リーク回避チェックリスト

3. 実務向けサンプルコードの取得

4. まとめのベストプラクティス

参考リンク

Go 1.22 の新機能と実務ベストプラクティス