channel

複数の goroutine が動くと、goroutine 間で値を受け渡す方法が必要になります。以下のように、go で起動した処理から計算結果を main に戻したい場面はよくあります。

go func() {
    result := fetch()
    // main にどうやって渡す?
}()

共有変数を経由して受け渡すと、複数の goroutine から同時アクセスされたときの結果が保証されず、データ競合の原因になります。

Go はこの課題に対して、共有メモリを直接読み書きするのではなく、channelを通してやり取りする仕組みを提供しています。Effective Go では、この方針が次のスローガンとして示されています。

Do not communicate by sharing memory; instead, share memory by communicating.

「メモリを共有して通信するのではなく、通信によってメモリを共有する」という意味で、channel を軸に goroutine 間のやり取りを設計する考え方の出発点になります。

1. channel の基本

channel は make で作り、<- 演算子で送受信します。書き方は以下のとおりです。

ch := make(chan 型)   // 型を送受信できる channel を作る
ch <- 値              // channel に値を送信する
値 := <-ch            // channel から値を受信する

次のコードは、別の goroutine から channel に 42 を送り、main 側で受信して表示する最小の例です。

package main

import "fmt"

func main() {
    ch := make(chan int)

    go func() {
        ch <- 42
    }()

    v := <-ch
    fmt.Println("受信:", v)
}

以下のような実行結果が表示されます。

受信: 42

別の goroutine が送信した 42 を、main 側の受信で受け取って表示できました。

コードを解説します。

ch := make(chan int)

make(chan int) は int 型を送受信できる channel を作ります。channel は goroutine 間で値を受け渡すためのパイプのような役割です。

go func() {
    ch <- 42
}()

無名関数を新しい goroutine として起動し、その中で ch <- 42 として channel に 42 を送信しています。

v := <-ch

<-ch で channel から値を受信し、v に代入しています。channel はデフォルトで同期で動き、送信側は受信されるまで、受信側は送信されるまで待ちます。

2. バッファ付き channel

先ほど扱った channel は、送信するたびに受信を待つ 同期 で動きます。そのため、「値を先にまとめて溜めておいて、あとから順に取り出したい」場面では、送信が受信に引きずられてしまい書きにくくなります。

こうした場合は、make の第2引数に容量を指定して バッファ付き channel を作ります。指定した容量が埋まるまでは受信を待たずに送信できるため、値を溜めておくキューのように扱えます。書き方は以下のとおりです。

ch := make(chan 型, 容量)

次のコードは、容量3の channel を用意し、4つ目の送信を別の goroutine から試みる例です。バッファが容量いっぱいのため4つ目の送信はブロックしますが、main 側が最初の値を受信して空きができた瞬間に、待機していた4つ目が入る様子を確認します。main.go を以下の内容に書き換えて保存し、go run main.go で実行します。

package main

import (
    "fmt"
    "time"
)

func main() {
    ch := make(chan int, 3)
    ch <- 1
    ch <- 2
    ch <- 3
    fmt.Println("1〜3を送信済み(バッファは容量いっぱい)")

    go func() {
        fmt.Println("4の送信を試行(バッファが空くまでブロック)")
        ch <- 4
        fmt.Println("4を送信できました")
    }()

    time.Sleep(500 * time.Millisecond)
    fmt.Println("受信:", <-ch)

    time.Sleep(500 * time.Millisecond)
    fmt.Println("受信:", <-ch)
    fmt.Println("受信:", <-ch)
    fmt.Println("受信:", <-ch)
}

以下のような実行結果が表示されます。

1〜3を送信済み(バッファは容量いっぱい)
4の送信を試行(バッファが空くまでブロック)
受信: 1
4を送信できました
受信: 2
受信: 3
受信: 4

1〜3 はバッファに空きがあるためすぐに送信できましたが、4つ目の ch <- 4 は goroutine 側でブロックしています。main 側が最初の値 1 を受信してバッファに空きができた瞬間に、待機していた ch <- 4 が完了していることが確認できます。

コードを解説します。

ch := make(chan int, 3)
ch <- 1
ch <- 2
ch <- 3

make(chan int, 3) で容量3のバッファ付き channel を作り、3つの値を送信しています。容量が埋まるまでは受信を待たずに送れます。ここまででバッファは容量いっぱいの状態です。

go func() {
    fmt.Println("4の送信を試行(バッファが空くまでブロック)")
    ch <- 4
    fmt.Println("4を送信できました")
}()

バッファが容量いっぱいの状態で ch <- 4 を実行するため、この送信は goroutine 側でブロックします。受信によってバッファに空きができるまで、次の行には進みません。

fmt.Println("受信:", <-ch)

main 側で最初の値を受信すると、バッファから 1 が取り出されて空きが1つでき、待機していた goroutine の ch <- 4 が完了します。以降の受信では 2・3・4 の順に、送信された順序どおり取り出せます。

バッファ付き channel は、値を先に溜めておいてから受信側で順に取り出す、キューのような使い方をしたい場合に使うことが一般的です。

3. channelのクローズ

複数の値を送信する場面では、受信側が「送信がいつ終わったか」を知る必要があります。もし送信の終わりを伝えないと、受信側は「まだ来るかもしれない」と受信を続けようとして、来ない値を待ってブロックしてしまいます。

3.1 close なしでの deadlock

ここでは、送信側は3つで送信を終えるのに対して、受信側は「4件届くはず」として for ループで4回受信を試みる、送信数と受信数で認識齟齬が起きた例で挙動を確認します。main.go を以下の内容に書き換えて保存し、go run main.go で実行します。

package main

import "fmt"

func main() {
    ch := make(chan int, 3)

    go func() {
        for i := 1; i <= 3; i++ { // 送信側は3つ送って終わる
            ch <- i
        }
    }()

    for i := 1; i <= 4; i++ { // 受信側は4件届くはずとして4回受信を試みる
        fmt.Printf("%d回目のループ\n", i)
        fmt.Println(<-ch)
    }
}

以下のような実行結果が表示されます。

1回目のループ
1
2回目のループ
2
3回目のループ
3
4回目のループ
fatal error: all goroutines are asleep - deadlock!

3周目までは <-ch で値を受信できていますが、4周目に入って <-ch が実行された時点で、受信側は「もう送信は来ない」ことを判断できず、来ない値を待ち続けてブロックしました。全ての goroutine がブロックした状態を Go ランタイムが deadlock として検出し、プログラムが強制終了しています。

3.2 close で送信終了を伝える

Go には、送信側から「もう送るものがない」ことを明示的に伝える手段として close が用意されています。書き方は以下のとおりです。

close(ch)              // 「もう送信はない」ことを受信側に伝える
for v := range ch {    // channel が閉じられるまで受信を続ける
    // v を使った処理
}

次のコードは、先ほどのコードに close(ch) を1行だけ追加した例です。受信側のループは4回のままにして、close の有無だけで挙動がどう変わるかを確認します。main.go を以下の内容に書き換えて保存し、go run main.go で実行します。

package main

import "fmt"

func main() {
    ch := make(chan int, 3)

    go func() {
        for i := 1; i <= 3; i++ { // 送信側は3つ送って終わる
            ch <- i
        }
        close(ch) // 送信終了を受信側に伝える
    }()

    for i := 1; i <= 4; i++ { // 受信側は4件届くはずとして4回受信を試みる
        fmt.Printf("%d回目のループ\n", i)
        fmt.Println(<-ch)
    }
}

以下のような実行結果が表示されます。

1回目のループ
1
2回目のループ
2
3回目のループ
3
4回目のループ
0

close(ch) を追加したことで、先ほどのような deadlock は発生しなくなりました。ただし4周目の <-ch は int のゼロ値である 0 を返しています。閉じた channel から受信すると、バッファに残った値を取り出し切ったあとはブロックせず、型のゼロ値が返る仕様です。

コードを解説します。

close(ch) // 送信終了を受信側に伝える

送信ループの直後で close(ch) を呼び出しています。閉じることで受信側に「もう送信はない」と伝わり、以降の <-ch はブロックせずゼロ値を返すようになります。

実際には、受信側で「あと何件届くか」を数えたくないケースが多くあります。そのため、上のプレースホルダで示した for v := range ch を使うのが一般的です。この書き方であれば、close が検知された時点でループが自動的に終了するため、受信件数を意識せずに書けます。閉じずに for range を使うと永久にブロックしてしまうので、送信側が閉じる責任を持つのが原則です。