Go言語のチャネルとは？ゴルーチン間通信をマスターして同期処理を理解しよう

Go言語

最終更新2025年8月18日

リンドくん

たなべ先生、Go言語で「チャネル」というものがあるって聞いたんですが、これって何ですか？ゴルーチンと関係があるんですか？

たなべ

チャネルはGo言語の最も強力な機能の一つなんだ。
ゴルーチン同士がデータをやり取りする「パイプ」のようなものだと考えてもらえばいいよ。

プログラミングを学んでいると、複数の処理を同時に実行したい場面によく遭遇します。
例えば、Webサーバーで複数のリクエストを同時に処理したり、大量のデータを並列で計算したりする場合です。

Go言語では、このような並行処理を「ゴルーチン」という軽量スレッドで実現します。
しかし、複数のゴルーチンが勝手に動いているだけでは、お互いの処理結果を共有したり、処理の順序を制御したりできません。

そこで登場するのがチャネル（channel）です。
チャネルを使うことで、ゴルーチン間で安全にデータを送受信し、同期処理を実現できるのです。

今回は、Go言語のチャネルについて、プログラミング初心者の方でも理解できるよう、基本概念から実践的な使い方まで詳しく解説していきます。

プログラミング学習でお悩みの方へ

HackATAは、エンジニアを目指す方のためのプログラミング学習コーチングサービスです。経験豊富な現役エンジニアがあなたの学習をサポートします。

✓ 質問し放題

✓ β版公開中（2025年内の特別割引）

HackATAの詳細を見る

チャネルとは何か？基本概念を理解しよう

リンドくん

チャネルって具体的にはどんなものなんですか？イメージがわかないんです...

たなべ

身近な例で説明しよう！郵便ポストを想像してみて。
手紙を投函する人と、配達員さんがいるよね？チャネルはまさにそのポストの役割なんだ。

チャネルの基本概念

Go言語のチャネルは、ゴルーチン間でデータを安全に送受信するための仕組みです。
以下の特徴があります。

型安全 → 特定の型のデータのみを送受信できます
同期機能 → データの送信と受信が同期されます
FIFO（先入先出） → 送信された順序でデータが受信されます

郵便ポストの例で考えると、以下のような関係になります。

手紙を投函する人 → データを送信するゴルーチン
郵便ポスト → チャネル
配達員 → データを受信するゴルーチン

チャネルの宣言と基本的な使い方

チャネルはmake関数を使って作成します。

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

// string型のチャネル
messages := make(chan string)

基本的な送受信の文法は以下の通りです。

// データの送信（チャネルに値を送る）
ch <- 42

// データの受信（チャネルから値を受け取る）
value := <-ch

矢印の向きに注目してください。<-の向きが、データの流れる方向を表しています。

実践的なチャネルの使い方

リンドくん

実際にコードで見てみたいです！どんな風に使うんですか？

たなべ

じゃあ、実際にコードを書いて確認してみよう。最初は簡単な例から始めるよ。

基本的なチャネル通信の例

まずは、最もシンプルなチャネル通信の例を見てみましょう。

package main

import (
    "fmt"
    "time"
)

func main() {
    // string型のチャネルを作成
    messages := make(chan string)

    // ゴルーチンを起動してメッセージを送信
    go func() {
        time.Sleep(2 * time.Second) // 2秒待機
        messages <- "Hello, Channel!" // チャネルにメッセージを送信
    }()

    // メッセージを受信するまで待機
    msg := <-messages
    fmt.Println(msg) // "Hello, Channel!" が出力される
}

このコードでは、以下の流れで処理が進みます。

チャネルの作成 → messagesという名前のstring型チャネルを作成
ゴルーチンの起動 → go func()で別のゴルーチンを起動
データの送信 → 2秒後にチャネルにメッセージを送信
データの受信 → メインゴルーチンがメッセージを受信して出力

チャネルによる同期処理

チャネルには重要な特徴があります。それは同期処理です。
データの送信側と受信側は、相手が準備できるまで待機します。

package main

import (
    "fmt"
    "time"
)

func worker(id int, jobs <-chan int, results chan<- int) {
    for job := range jobs {
        fmt.Printf("Worker %d processing job %d\n", id, job)
        time.Sleep(1 * time.Second) // 作業をシミュレート
        results <- job * 2 // 結果をチャネルに送信
    }
}

func main() {
    jobs := make(chan int, 5)
    results := make(chan int, 5)

    // 3つのワーカーゴルーチンを起動
    for i := 1; i <= 3; i++ {
        go worker(i, jobs, results)
    }

    // 5つの仕事をチャネルに送信
    for j := 1; j <= 5; j++ {
        jobs <- j
    }
    close(jobs) // チャネルを閉じる

    // 結果を受信
    for r := 1; r <= 5; r++ {
        result := <-results
        fmt.Printf("Result: %d\n", result)
    }
}

この例では、ワーカープールパターンを実装しています。複数のワーカーが並行して仕事を処理し、結果を集約する仕組みです。

バッファ付きチャネルとselect文

リンドくん

さっきのコードで「バッファ」って出てきましたが、これは何ですか？

たなべ

バッファ付きチャネルは、一時的にデータを貯めておける「倉庫」がついたチャネルなんだ。
これがあると、送信側と受信側のタイミングがずれても大丈夫になるよ。

バッファ付きチャネル

通常のチャネルは同期的です。つまり、送信者と受信者が同時に準備できるまで処理が止まります。
しかし、バッファ付きチャネルを使うと、指定した数まではデータを貯めておくことができます。

package main

import "fmt"

func main() {
    // バッファサイズ3のチャネルを作成
    ch := make(chan string, 3)

    // バッファがあるので、受信者がいなくても送信できる
    ch <- "メッセージ1"
    ch <- "メッセージ2"
    ch <- "メッセージ3"

    // バッファからデータを受信
    fmt.Println(<-ch) // メッセージ1
    fmt.Println(<-ch) // メッセージ2
    fmt.Println(<-ch) // メッセージ3
}

バッファ付きチャネルの利点は以下の通りです。

非同期処理 → 送信者と受信者のタイミングを緩和
スループット向上 → 一時的な処理速度の差を吸収
デッドロック回避 → 適切に使うことで処理の停止を防げる

select文による複数チャネルの制御

select文を使うと、複数のチャネル操作を同時に監視できます。

package main

import (
    "fmt"
    "time"
)

func main() {
    ch1 := make(chan string)
    ch2 := make(chan string)

    // 1秒後にch1にメッセージを送信
    go func() {
        time.Sleep(1 * time.Second)
        ch1 <- "チャネル1からのメッセージ"
    }()

    // 2秒後にch2にメッセージを送信
    go func() {
        time.Sleep(2 * time.Second)
        ch2 <- "チャネル2からのメッセージ"
    }()

    // 最初に準備できたチャネルからデータを受信
    for i := 0; i < 2; i++ {
        select {
        case msg1 := <-ch1:
            fmt.Println("受信:", msg1)
        case msg2 := <-ch2:
            fmt.Println("受信:", msg2)
        case <-time.After(3 * time.Second):
            fmt.Println("タイムアウト")
        }
    }
}

select文では以下のような制御が可能です。

複数チャネルの監視 → どれか一つが準備できたら実行
タイムアウト処理 → time.Afterを使った時間制限
デフォルト処理 → default句でノンブロッキング処理

チャネル使用時の注意点とベストプラクティス

よくある間違いと対策

1. デッドロックの発生

// 悪い例 デッドロックが発生
func badExample() {
    ch := make(chan int)
    ch <- 42 // 受信者がいないため、ここで処理が止まる
    value := <-ch
    fmt.Println(value)
}

// 良い例 ゴルーチンを使用
func goodExample() {
    ch := make(chan int)
    go func() {
        ch <- 42
    }()
    value := <-ch
    fmt.Println(value)
}

2. チャネルのクローズ忘れ

// 良い例 適切にチャネルをクローズ
func properClose() {
    ch := make(chan int)
    go func() {
        defer close(ch) // 関数終了時に必ずクローズ
        for i := 0; i < 5; i++ {
            ch <- i
        }
    }()
    
    for value := range ch { // rangeでチャネルを受信
        fmt.Println(value)
    }
}