【Go言語】goroutineとchannelの使い方!並行処理の基本を解説

【Go言語】goroutineとchannelの使い方!並行処理の基本を解説

PR Amazonのアソシエイトとして、ITナレッジライフは適格販売により収入を得ています。

記事の文字数:2,837

Go言語(Golang)のgoroutineとchannelの使い方を徹底解説!軽量スレッドによる並行処理の起動方法から、channelを使ったデータ送受信、バッファの有無による挙動の違い、sync.WaitGroupやselect文による制御まで分かりやすく紹介します。

ITエンジニアにお勧めの本 ↗

おすすめ

エンジニアが知っておきたい思考の整理術 複雑な情報を【理解する】【伝える】テクニック

難易度
実用性
図解

思考の整理というテーマを、実務ですぐに使える具体的な「技術」として落とし込んだ一冊です。

ベストセラー

世界一流エンジニアの思考法

難易度
実用性
思考法

技術スキル以上に大切な「考え方」をアップデートできる。世界基準の効率的な仕事術が学べます。

文系社会人のためのIT資格の歩き方: 文系のあなたに最適な道をご提案します (YKcreate kiki)

難易度
実用性
キャリア度

ロードマップが非常に明確。キャリアプランを見据えた、無駄のない学習順序を提案してくれます。

エンジニアを説明上手にする本 相手に応じた技術情報や知識の伝え方

難易度
実用性
コミュ力

「伝える技術」もエンジニアの重要なスキル。相手の視点に立った、具体的な説明のコツが満載です。

技術広報入門 ー テックブログから始めるエンジニアカルチャーのつくり方

難易度
実用性
独自性

テックブログを入口にエンジニア組織の文化をどう設計し、育てていくかという実践論が学べます。

複数の一連のタスクを高速に処理したり、大量のAPIAPI [エーピーアイ]Application Programming Interface。異なるソフトウェア間の接続口リクエストやバックグラウンド処理を効率的に捌いたりする際、プログラミング言語ごとの「並行処理(Concurrency)」の実装方法が重要になります。他言語での非同期処理については Pythonのasync/awaitの使い方 でも詳しく解説しています。

GoGo [ゴー]Google開発のシンプルで高速な言語言語(GolangGolang [ゴーラング]Goプログラミング言語の別称)では、言語のコア機能として goroutine(ゴルーチン) と channel(チャネル) が組み込まれており、比較的シンプルに並行処理を記述できます。Goの設計哲学として知られる 「 メモリを共有して通信するのではなく、通信によってメモリを共有する 」 という思想は、まさにこの2つの機能によって実現されています。

この記事では、goroutineの基本構文からchannelを介したデータの送受信、バッファ付きチャネルの扱い方、sync.WaitGroup や select 文を使った実践的な制御パターン、初心者が陥りやすい注意点までを体系的に解説します。

この記事でわかること

  • goroutineの仕組みとOSOS [オーエス]Operating System。基本ソフトウェアスレッドとの違い、基本的な起動方法
  • channelを使ったgoroutine間の安全なデータ送受信と同期
  • バッファなしチャネルとバッファ付きチャネルの挙動の違い
  • close() と range を使ったチャネルの反復受信
  • sync.WaitGroup によるgoroutineの完了待ち合わせ
  • select 文による複数チャネルの多重待ち受けとタイムアウト処理
  • デッドロックやgoroutineリークを防ぐための注意点

確認した環境

本記事で解説するコードは、以下の環境を基準に動作を確認・検証しています。

goroutine(ゴルーチン)とは?

goroutine とは、Goランタイムによって管理される 極めて軽量な並行実行単位(グリーンスレッド) です。

OSスレッドは、OSや実行環境によって異なりますが、一般的にgoroutineより大きなスタック領域を必要とします。また、スレッドの生成やコンテキストスイッチにも一定のオーバーヘッドがあります。

これに対してgoroutineは、 初期スタックサイズが約2KB から始まり、必要に応じて動的に拡張・縮小されます。そのため、OSスレッドと比較して少ないリソースで多数の並行処理を実行できます。ただし、実際に起動できるgoroutineの数は、処理内容やメモリ使用量などのシステムリソースに依存します。

flowchart TD subgraph OSThread["OSスレッド(スタック・切替コスト大)"] T1["OSスレッド 1"] T2["OSスレッド 2"] end subgraph GoRuntime["Goランタイム(Goスケジューラ)"] G1["goroutine 1 (初期約2KB〜)"] G2["goroutine 2 (初期約2KB〜)"] G3["goroutine 3 (初期約2KB〜)"] G4["goroutine 4 (初期約2KB〜)"] end GoRuntime -->|M:Nマッピング| OSThread

goroutineの基本的な起動方法

関数呼び出しの直前に go キーワード を付与するだけで、その関数が新しいgoroutineとして非同期に実行されます。

package main
import (
"fmt"
"time"
)
func sayHello(name string) {
for i := 1; i <= 3; i++ {
fmt.Printf("[%s] count: %d\n", name, i)
time.Sleep(100 * time.Millisecond)
}
}
func main() {
// 新しいgoroutineとして非同期実行
go sayHello("goroutine")
// メインの処理
sayHello("main")
}

実行結果の例:

[main] count: 1
[goroutine] count: 1
[main] count: 2
[goroutine] count: 2
[main] count: 3
[goroutine] count: 3

上記のコードでは、go sayHello("goroutine") を呼び出すことで、バックグラウンドで並行してカウント処理が進行しています。なお、goroutineの実行順序はGoランタイムのスケジューラによって決定されるため、実行するたびに異なる場合があります。上記はあくまで出力例であり、必ず同じ順序で表示されるわけではありません。

注意:main関数の終了=プログラム全体の終了

goroutineを扱う上で最も初歩的な注意点は、 「 main 関数がリターンすると、実行中のすべてのgoroutineが強制終了する 」 という点です。

例えば、以下のように main 関数側で何も待機処理を行わない場合、goroutineの処理が始まる前にプログラム自体が終了してしまい、何も出力されないケースがあります。

func main() {
go fmt.Println("Hello from goroutine")
// main関数が即座に終了するため、上のPrintlnが実行されない可能性がある
}

goroutineの完了を待機したり、安全に結果を受け取ったりするために利用するのが channel や sync.WaitGroup です。

スポンサーリンク

channel(チャネル)とは?

channel とは、異なるgoroutine間で 値を安全に送受信し、実行の同期を取るための通信パイプ です。

マルチスレッドプログラミングでは、複数のスレッドが同一のメモリ領域(変数など)に同時にアクセスすることで発生する「競合状態(Race Condition)」を防ぐために、ミューテックス(排他制御)を用いた複雑なロック管理が必要になることが多くありました。

Goでは、チャネルを通じてgoroutine間でデータを受け渡し、通信によって処理の同期を取る設計が推奨されています。この方法を活用することで、共有メモリへの直接アクセスや複雑なロック管理を減らせます。

ただし、チャネルでポインタやスライスなどを送信しても、参照先のメモリが自動的にコピーされたり、所有権が移譲されたりするわけではありません。複数のgoroutineから同じメモリ領域にアクセスする場合は、引き続き適切な同期制御が必要です。

sequenceDiagram autonumber participant G1 as goroutine 1(送信側) participant CH as channel participant G2 as goroutine 2(受信側) G1->>CH: 値を送信 (ch <- data) Note over CH: データの中継・同期 CH->>G2: 値を受信 (data := <-ch)

チャネルの宣言と送受信構文

チャネルは組み込み関数の make を使用して作成します。型には送受信するデータの型を指定します。

// int型の値を送受信するチャネルを作成
ch := make(chan int)

データの送信と受信には、矢印演算子(<-)を使用します。

  • 送信: ch <- value(チャネルへ値を流し込む)
  • 受信: value := <-ch(チャネルから値を取り出す)

以下は、goroutineで計算した結果をchannel経由で main 関数へ受け渡す基本的なコード例です。

package main
import "fmt"
func calculateSum(a, b int, resultChan chan int) {
sum := a + b
// チャネルへ計算結果を送信
resultChan <- sum
}
func main() {
// int型チャネルを作成
resultChan := make(chan int)
// 計算処理をgoroutineで実行
go calculateSum(10, 25, resultChan)
// チャネルから計算結果を受信(送信側が値を書き込むまでここで待機)
total := <-resultChan
fmt.Printf("計算結果: %d\n", total)
}

実行結果:

計算結果: 35

<-resultChan による受信処理は、送信側がチャネルにデータを書き込むまで処理を自動的に一時停止(ブロック)します。そのため、明示的なスリープ処理を入れなくても安全に結果を待機できます。

バッファなしチャネル vs バッファ付きチャネル

チャネルには 「 バッファなしチャネル(Unbuffered Channel) 」 と 「 バッファ付きチャネル(Buffered Channel) 」 の2種類が存在し、ブロック(待機)の挙動が異なります。

チャネル種別作成構文送信側のブロック条件受信側のブロック条件
バッファなしmake(chan T)受信側が受け取る準備ができるまで待機送信側がデータを送るまで待機
バッファ付きmake(chan T, 容量)バッファの容量(キュー)が満杯の間待機バッファが空の間待機

1. バッファなしチャネル(Unbuffered)

容量を指定せずに作成したチャネル(make(chan int))は、バッファを持ちません。

このチャネルでは、送信操作を行うと、 受信側のgoroutineが受信操作を実行するまで送信側がブロック されます。同様に、受信側も送信側が送信操作を実行するまでブロックされます。送信側と受信側の通信操作が成立することで、 両方のgoroutineの間で同期(ハンドシェイク) が取られます。

flowchart LR Sender["送信側 goroutine"] -->|"ch <- val\n(受信操作の実行まで待機)"| Receiver["受信側 goroutine\n<-ch"]

2. バッファ付きチャネル(Buffered)

make の第2引数に正の整数を指定すると、内部に指定個数分のキュー領域を持つ バッファ付きチャネル になります。

// 最大3個のstringを保持できるバッファ付きチャネル
messages := make(chan string, 3)

バッファに空きがある限り、受信側の存在に関係なく送信側はブロックされずに処理を継続できます。バッファが満杯になった段階で初めて、データが取り出されるまで送信側がブロックされます。

package main
import "fmt"
func main() {
// キャパシティ2のバッファ付きチャネルを作成
ch := make(chan string, 2)
// バッファに空きがあるため、受信側がいなくてもブロックされない
ch <- "Hello"
ch <- "World"
fmt.Printf("現在のバッファ長: %d, キャパシティ: %d\n", len(ch), cap(ch))
// バッファからデータを取り出し
fmt.Println(<-ch)
fmt.Println(<-ch)
}

実行結果:

現在のバッファ長: 2, キャパシティ: 2
Hello
World
スポンサーリンク

チャネルのクローズと range による反復受信

送信側がすべてのデータを送り終えたことを受信側に伝えるために、組み込み関数 close(ch) を使用します。

range を使った受信ループ

チャネルに対して for range ループを使用すると、チャネルから値を順番に受信し続けることができます。チャネルがクローズされた後も、バッファに未受信のデータが残っていればそれらをすべて受信し、データがなくなるとループが自動的に終了します。

package main
import "fmt"
func produceNumbers(ch chan int) {
for i := 1; i <= 3; i++ {
ch <- i
}
// すべての送信が終わったらチャネルをクローズ
close(ch)
}
func main() {
ch := make(chan int)
go produceNumbers(ch)
// チャネルがクローズされるまでループが自動的に継続する
for num := range ch {
fmt.Printf("受信: %d\n", num)
}
fmt.Println("すべての受信が完了しました")
}

実行結果:

受信: 1
受信: 2
受信: 3
すべての受信が完了しました

もし送信側で close(ch) を呼ばなかった場合、受信側の for range は次のデータが来るのを待ち続け、最終的にデッドロック(deadlock)エラーとなります。

チャネルの状態確認(2値受け取り)

チャネルから値を受信する際、2つ目の戻り値(booleanboolean [ブーリアン]真(true)または偽(false)の2値を表すデータ型)を受け取ることで、 受信した値が通常の送信によるものか、クローズ済みかつバッファが空の状態で返されたゼロ値なのか を判定できます。

チャネルをクローズした直後でも、バッファに未受信のデータが残っている場合は引き続きその値(ok == true)が受信されます。ゼロ値と false が返るのは、チャネルがクローズされ、かつバッファ内のデータもすべて受信し終わった後です。

val, ok := <-ch
if !ok {
// チャネルがクローズされ、バッファ内の値もすべて受信済み
fmt.Println("チャネルはクローズされ、受信できる値はありません")
} else {
fmt.Println("受信した値:", val)
}

実践的な並行処理パターン

実際のGo開発で頻繁に利用される2つの代表的なパターンを紹介します。

1. sync.WaitGroup による複数goroutineの完了待機

複数のgoroutineを同時に立ち上げ、それらすべての処理が完了するのを待ち合わせたい場合は、標準パッケージ sync の WaitGroup を利用するのが定石です。

package main
import (
"fmt"
"sync"
"time"
)
func worker(id int, wg *sync.WaitGroup) {
// 関数の終了時にDoneを呼び出して完了を通知
defer wg.Done()
fmt.Printf("[Worker %d] 開始\n", id)
time.Sleep(150 * time.Millisecond)
fmt.Printf("[Worker %d] 完了\n", id)
}
func main() {
var wg sync.WaitGroup
// 3つの並行ワーカーを起動
for i := 1; i <= 3; i++ {
wg.Add(1) // 待機カウンタを1増やす
go worker(i, &wg)
}
// すべてのWorkerが完了(カウンタが0になる)するまで待機
wg.Wait()
fmt.Println("すべてのワーカー処理が完了しました")
}

実行結果の例:

[Worker 3] 開始
[Worker 1] 開始
[Worker 2] 開始
[Worker 2] 完了
[Worker 3] 完了
[Worker 1] 完了
すべてのワーカー処理が完了しました

各goroutineの実行順序はGoランタイムのスケジューラによって決定されるため、実行するたびに開始や完了の順序は変わります。上記はあくまで出力例です。

sync.WaitGroup の基本ステップは以下の3点です。

  1. wg.Add(1): 起動するgoroutineの数だけカウンタを増やします。
  2. wg.Done(): 各goroutineの完了時にカウンタを1減らします(defer で呼ぶのが安全です)。
  3. wg.Wait(): カウンタが0になるまで呼び出し元の処理をブロックします。

[!NOTE] sync.WaitGroup を関数に引数として渡す場合は、必ず ポインタ(*sync.WaitGroup) として渡してください。値渡しをするとコピーが作成され、完了通知が正しく反映されなくなります。

また、カウンタが 0 の状態から正の値へ増やす wg.Add() は、 wg.Wait() より前(通常はgoroutineを起動する直前) に実行する必要があります。次のようにgoroutineの内部で wg.Add(1) を呼び出すと、Add() が実行される前に wg.Wait() が実行されてカウンタが 0 と判断され、待機せずに通過してしまう可能性があります。

// 避けるべき例:goroutine内でAdd()を呼ぶと、Wait()が先に通過する可能性がある
go func() {
wg.Add(1)
defer wg.Done()
// 処理
}()
wg.Wait()

2. select 文による複数チャネルの多重待ち受けとタイムアウト

select 文 を使うと、複数のチャネル通信操作を同時に待機し、準備ができた通信を処理できます。

特にAPI通信やバッチ処理で一定時間応答がない場合に処理を打ち切る「タイムアウト制御」を書く際によく利用されます。なお、select でタイムアウトが発生しても 起動したgoroutineは自動的には終了しない ため、単なる time.After() の分岐だけで受信側が抜けてしまうと、送信側goroutineがチャネルへの書き込み待ちで永久にブロック(goroutineリーク)されるおそれがあります。

そのため、タイムアウト時に処理側のgoroutineへもキャンセルを通知できるよう、 context.WithTimeout() を組み合わせるのが実務での安全な書き方です。

package main
import (
"context"
"fmt"
"time"
)
func fetchExternalData(ctx context.Context) (string, error) {
select {
case <-time.After(2 * time.Second):
return "外部APIからの取得データ", nil
case <-ctx.Done():
return "", ctx.Err()
}
}
func main() {
ctx, cancel := context.WithTimeout(
context.Background(),
1*time.Second,
)
defer cancel()
resultChan := make(chan string, 1)
errorChan := make(chan error, 1)
go func() {
result, err := fetchExternalData(ctx)
if err != nil {
errorChan <- err
return
}
resultChan <- result
}()
select {
case res := <-resultChan:
fmt.Printf("成功: %s\n", res)
case err := <-errorChan:
fmt.Printf("エラー: %v\n", err)
case <-ctx.Done():
fmt.Println("エラー: タイムアウトが発生しました")
}
}

実行結果の例:

エラー: タイムアウトが発生しました

このコードでは、context.WithTimeout で1秒のタイムアウトを設定し、時間切れになると ctx.Done() チャネルがクローズされます。これにより main 側がタイムアウトを検知できるだけでなく、fetchExternalData 側の select でも <-ctx.Done() が成立してgoroutineを安全に終了できます(なお、実行タイミングによっては fetchExternalData 側が先にキャンセルを検知して errorChan へ送信し、エラー: context deadline exceeded と出力される場合もあります)。

また、resultChan と errorChan にサイズ 1 のバッファを持たせている点も重要です。main 側の select が先に case <-ctx.Done(): を選んで抜けた場合でも、goroutine側がチャネル送信でブロックされずに終了できます。

なお、context はgoroutineを強制終了させるものではなく、キャンセルを通知する仕組みです。そのため、実際の処理側でも ctx.Done() を確認して適切に処理を終了する実装が必要であり、外部API通信を行う場合は http.NewRequestWithContext のように通信処理自体も context によるキャンセルに対応させてください(time.After(duration) は指定時間経過後に現在時刻を送信するチャネルを返す仕組みです)。

スポンサーリンク

goroutineとchannelを扱う際の注意点

並行処理を安全に実装するために、必ず押さえておくべき重要な注意点があります。

1. デッドロック(deadlock)の発生

すべてのgoroutineが送受信待ちで停止し、プログラム全体が進まなくなると、Goランタイムは fatal error: all goroutines are asleep - deadlock! というエラーを出力して強制終了します。

例えば、バッファなしチャネルに対して、同一のgoroutine内で受信側がいないまま送信を行うとデッドロックが発生します。

// 誤った例:受信側のgoroutineがいないため永久にブロックされる
func main() {
ch := make(chan int)
ch <- 100 // ここでデッドロック発生!
fmt.Println(<-ch)
}

2. クローズ済みチャネルへの送信禁止

すでに close() されたチャネルに対してデータを送信しようとすると、実行時パニック(panic)が発生します。

  • クローズされたチャネルへの送信: パニック(panic: send on closed channel)
  • クローズされたチャネルの二重クローズ: パニック(panic: close of closed channel)
  • クローズされたチャネルからの受信: パニックにはならず、バッファに未受信データが残っていればその値(2つ目の戻り値は true)、未受信データがなければ型のゼロ値と false が返る

原則として、チャネルのクローズは 送信側の責任 で行います。ただし、複数のgoroutineが同じチャネルに送信する場合は、各送信側が個別に close() を呼んではいけません(他の送信側がまだ送信中にクローズ済みチャネルへ書き込んでパニックになるためです)。このような場合は、sync.WaitGroup などで すべての送信処理が完了したことを確認したうえで、管理役のgoroutineが1回だけクローズする ように設計しましょう。

3. goroutineリーク(メモリリーク)の防止

チャネルへの送信または受信の待ち合わせが解消されず、goroutineがメモリ上に永遠に残り続ける現象を goroutineリーク と呼びます。

例えば、受信側が途中でリターンしてしまい、送信側のgoroutineがチャネルへの書き込み待ちで永遠にブロックされるといったケースです。コンテキスト(context.Context)を用いたキャンセル通知や、バッファサイズの適切な設計によって、不要になったgoroutineが確実に終了する経路を確保することが重要です。

まとめ

Go言語のgoroutineとchannelを活用することで、軽量かつ安全に並行処理を組み立てることができます。

本記事の要点を以下にまとめます。

  • goroutine: go キーワードで起動する軽量な並行単位。初期スタック約2KBから開始し効率よく動作する
  • channel: goroutine間で安全にデータをやり取りし、同期を取るパイプ
  • バッファ: バッファなしは同期ハンドシェイク、バッファ付きは一定量まで非同期送信が可能
  • 反復受信: close() と for range で安全に全データを受信完了できる
  • 制御構文: 完了待機には sync.WaitGroup、多重待ちやタイムアウトには select 文(+ context)を活用する

並行処理の基本を押さえることで、Webサーバーのバックエンド処理やデータパイプラインなど、高スループットが求められるGoアプリケーションをより堅牢に開発できるようになります。

関連記事

【Python】async/awaitの使い方!非同期処理の基本を解説
ITナレッジライフ

【Python】async/awaitの使い方!非同期処理の基本を解説

Pythonのasync/awaitと標準ライブラリasyncioを使った非同期処理の使い方を徹底解説!コルーチンの基本構文から、asyncio.gatherやcreate_taskによる並行実行、タイムアウト制御、time.sleepを使わない注意点まで実機検証コード付きで紹介します。


以上で本記事の解説を終わります。
よいITライフを!
スポンサーリンク
ITナレッジライフ 運営者
この記事を書いた人

Z (ITナレッジライフ)

現役のITエンジニア。Linux、プログラミング、IT用語など、日々の業務で得た「痒いところに手が届く」技術情報を発信しています。

プロフィールと編集ポリシーを見る →
スポンサーリンク

ITエンジニアにお勧めの本 ↗

おすすめ

エンジニアが知っておきたい思考の整理術 複雑な情報を【理解する】【伝える】テクニック

難易度
実用性
図解

思考の整理というテーマを、実務ですぐに使える具体的な「技術」として落とし込んだ一冊です。

スポンサーリンク

人気記事


記事を評価

Thanks!
目次
Scroll to Top