Go言語チャネルバッファの使い方と活用法について解説

package main
import (
	"fmt"
)
func main() {
	// バッファサイズ3の整数型チャネルを作成
	channel := make(chan int, 3)
	// チャネルに対して連続して送信
	channel <- 10 // バッファに1つ目の値が入る
	channel <- 20 // バッファに2つ目の値が入る
	channel <- 30 // バッファに3つ目の値が入る
	// バッファがいっぱいの場合、次の送信は受信するまでブロックされる
	// <-channel を呼ぶ前に送信するとブロックする実験が可能
	// 受信して出力
	fmt.Println(<-channel)
	fmt.Println(<-channel)
	fmt.Println(<-channel)
}

10
20
30

// 型Tのバッファ容量bufferSizeのチャネルを生成
channel := make(chan T, bufferSize)

package main
import (
	"fmt"
)
func main() {
	// 整数型のバッファ付きチャネルを容量5で作成
	intChannel := make(chan int, 5)
	// 送信処理
	for i := 1; i <= 5; i++ {
		intChannel <- i
	}
	// 受信処理
	for i := 1; i <= 5; i++ {
		fmt.Println(<-intChannel)
	}
}

1
2
3
4
5

package main
import (
	"fmt"
)
func main() {
	// バッファ付きチャネルを作成(バッファサイズは3)
	dataChannel := make(chan string, 3)
	// 送信側のゴルーチン
	go func() {
		// バッファに連続してデータを送信
		dataChannel <- "データ1"
		dataChannel <- "データ2"
		dataChannel <- "データ3"
		// チャネルを閉じることで送信完了を通知
		close(dataChannel)
	}()
	// 受信側：チャネルが閉じるまで受信処理を行う
	for data := range dataChannel {
		fmt.Println(data)
	}
}

データ1
データ2
データ3

package main
import (
	"fmt"
	"sync"
	"time"
)
func main() {
	// 整数型のバッファ付きチャネルを作成(バッファサイズは5)
	channel := make(chan int, 5)
	var wg sync.WaitGroup
	// 送信ゴルーチンの数
	senderCount := 3
	// 各送信ゴルーチンで異なる値を送信
	for i := 1; i <= senderCount; i++ {
		wg.Add(1)
		go func(id int) {
			defer wg.Done()
			// 各ゴルーチンが3つの値を送信
			for j := 1; j <= 3; j++ {
				val := id*10 + j
				channel <- val // バッファに送信
				time.Sleep(100 * time.Millisecond)
			}
		}(i)
	}
	// 別ゴルーチンで受信処理
	go func() {
		// 送信が全て完了するまで待ってからチャネルを閉じる
		wg.Wait()
		close(channel)
	}()
	// 受信側：チャネルが閉じるまで値を受信し出力する
	for num := range channel {
		fmt.Println("受信した値:", num)
	}
}

受信した値: 11
受信した値: 12
受信した値: 13
受信した値: 21
受信した値: 22
受信した値: 23
受信した値: 31
受信した値: 32
受信した値: 33

package main
import (
	"fmt"
	"time"
)
func main() {
	// 文字列型のバッファ付きチャネルを作成(バッファサイズは4)
	messageChannel := make(chan string, 4)
	// 送信ゴルーチン：短時間で複数のメッセージを送信
	go func() {
		for i := 1; i <= 4; i++ {
			messageChannel <- "メッセージ" + fmt.Sprint(i)
		}
		// 送信完了後にチャネルを閉じる
		close(messageChannel)
	}()
	// 少し待ってから受信処理を開始する(タイミング調整)
	time.Sleep(500 * time.Millisecond)
	for msg := range messageChannel {
		fmt.Println("処理中:", msg)
	}
}

処理中: メッセージ1
処理中: メッセージ2
処理中: メッセージ3
処理中: メッセージ4

package main
import (
	"fmt"
	"sync"
	"time"
)
func main() {
	// 整数型のバッファ付きチャネルを作成(バッファサイズは3)
	channel := make(chan int, 3)
	var wg sync.WaitGroup
	// 複数の送信ゴルーチンからデータを送信
	sender := func(id int) {
		defer wg.Done()
		for j := 1; j <= 2; j++ {
			fmt.Printf("送信ゴルーチン%dが値%dを送信\n", id, j)
			channel <- id*10 + j
			time.Sleep(50 * time.Millisecond)
		}
	}
	// 送信ゴルーチンの起動
	for i := 1; i <= 2; i++ {
		wg.Add(1)
		go sender(i)
	}
	// 全ての送信が完了したら、チャネルを閉じる
	go func() {
		wg.Wait()
		close(channel)
	}()
	// 受信側：チャネルが閉じるまで値を受信する。デッドロック回避のため無限ループを防ぐ。
	for value := range channel {
		fmt.Println("受信した値:", value)
	}
}

送信ゴルーチン1が値1を送信
送信ゴルーチン2が値1を送信
送信ゴルーチン1が値2を送信
受信した値: 11
送信ゴルーチン2が値2を送信
受信した値: 21
受信した値: 12
受信した値: 22

package main
import (
	"fmt"
	"sync"
	"time"
)
func main() {
	// 整数型バッファ付きチャネル(容量4)を作成
	channel := make(chan int, 4)
	var wg sync.WaitGroup
	// 送信ゴルーチン：非同期にデータを送信
	for i := 1; i <= 4; i++ {
		wg.Add(1)
		go func(val int) {
			defer wg.Done()
			channel <- val
			fmt.Println("送信:", val)
		}(i)
	}
	// 全ての送信処理が完了した後にチャネルを閉じる
	go func() {
		wg.Wait()
		close(channel)
	}()
	// 受信側：チャネルからデータを順次取り出す
	for num := range channel {
		fmt.Println("受信:", num)
		time.Sleep(100 * time.Millisecond)
	}
}

送信: 1
送信: 2
送信: 3
送信: 4
受信: 1
受信: 2
受信: 3
受信: 4