[インデックス 18372] ファイルの概要
このコミットは、Go言語のランタイムにおけるチャネル（chan）のテストを拡充するものです。具体的には、src/pkg/runtime/chan_test.go ファイルに多数の新しいテストケースが追加され、既存のテストも一部修正されています。これにより、Goのチャネルの挙動が様々な条件下でより堅牢に検証されるようになります。
コミット
commit d62379eef5c0834e4fe70fb42bc9c87b7a1fd879
Author: Dmitriy Vyukov <dvyukov@google.com>
Date: Tue Jan 28 22:45:14 2014 +0400
runtime: more chan tests
LGTM=bradfitz
R=golang-codereviews, bradfitz
CC=golang-codereviews
https://golang.org/cl/57390043
GitHub上でのコミットページへのリンク
https://github.com/golang/go/commit/d62379eef5c0834e4fe70fb42bc9c87b7a1fd879
元コミット内容
runtime: more chan tests
LGTM=bradfitz
R=golang-codereviews, bradfitz
CC=golang-codereviews
https://golang.org/cl/57390043
変更の背景
Go言語のチャネルは、ゴルーチン間の安全な通信と同期のための基本的なプリミティブです。その正確な動作は、Goプログラムの並行性の健全性を保証するために極めて重要です。このコミットが行われた2014年1月時点では、Go言語はまだ比較的新しく、ランタイムの安定性とパフォーマンスを向上させるための継続的な努力が払われていました。
チャネルの動作は、バッファリングの有無、送受信のブロック挙動、クローズ時の挙動、複数のゴルーチンからのアクセスなど、多岐にわたる複雑なシナリオを含みます。これらの複雑な相互作用において、デッドロック、データ競合、または予期せぬ動作が発生しないことを保証するためには、包括的で堅牢なテストスイートが不可欠です。
このコミットは、既存のチャネルテストをさらに強化し、より多くのエッジケースや並行シナリオをカバーすることを目的としています。特に、selectステートメントの複雑な相互作用や、異なるバッファサイズでのチャネルの挙動に焦点を当てたテストが追加されています。これにより、チャネルの実装における潜在的なバグを早期に発見し、Goランタイム全体の信頼性を向上させることが期待されます。
前提知識の解説
このコミットの変更内容を理解するためには、以下のGo言語の基本的な概念とテストに関する知識が必要です。
Go言語のチャネル (Channels)
チャネルは、Goにおけるゴルーチン間の通信メカニズムです。チャネルを通じて値を送受信することで、ゴルーチンは安全にデータを共有し、同期を取ることができます。
- チャネルの作成:
make(chan Type, capacity)で作成します。capacityが0の場合はバッファなしチャネル（unbuffered channel）、0より大きい場合はバッファありチャネル（buffered channel）となります。 - 送受信:
ch <- value: チャネルchにvalueを送信します。value := <-ch: チャネルchから値を受信します。value, ok := <-ch: チャネルchから値を受信し、チャネルがクローズされていなければokはtrue、クローズされていればfalseとなります。
- バッファなしチャネル: 送信は受信側が準備できるまでブロックし、受信は送信側が準備できるまでブロックします。同期的な通信に使用されます。
- バッファありチャネル: バッファが満杯になるまで送信はブロックせず、バッファが空になるまで受信はブロックしません。非同期的な通信に使用されます。
- チャネルのクローズ:
close(ch)でチャネルをクローズします。クローズされたチャネルへの送信はパニックを引き起こしますが、受信はバッファ内のすべての値が受信された後、ゼロ値とok=falseを返します。
select ステートメント
select ステートメントは、複数のチャネル操作を待機し、準備ができた最初の操作を実行するために使用されます。
case句: 各case句はチャネルの送受信操作を含みます。default句:default句が存在する場合、どのcase句もすぐに実行できないときにdefault句が実行されます。default句がない場合、selectはチャネル操作が準備できるまでブロックします。- ランダムな選択: 複数の
case句が同時に準備できた場合、selectはその中からランダムに1つを選択して実行します。これは、公平性を保証し、特定のチャネル操作が常に優先されることを防ぐために重要です。
Goのテストフレームワーク (testing パッケージ)
Goには、標準ライブラリとして軽量なテストフレームワークが組み込まれています。
- テスト関数の命名:
Testで始まり、その後に続く名前が大文字で始まる関数（例:func TestXxx(t *testing.T)）がテスト関数として認識されます。 *testing.T: テストの実行状態や結果を報告するためのメソッドを提供します。t.Fatalf(...): テストを失敗させ、メッセージを出力してテストを終了します。t.Errorf(...): テストを失敗させ、メッセージを出力しますが、テストは続行されます。
testing.Short():-shortフラグが指定された場合にtrueを返します。これにより、時間のかかるテストをスキップしたり、テストの反復回数を減らしたりすることができます。runtime.GOMAXPROCS(): Goプログラムが使用するOSスレッドの最大数を設定または取得します。並行テストにおいて、ゴルーチンのスケジューリング挙動を制御するために使用されることがあります。sync.WaitGroup: 複数のゴルーチンの完了を待機するために使用されます。Addでカウンタを増やし、Doneで減らし、Waitでカウンタがゼロになるまでブロックします。sync/atomicパッケージ: アトミック操作（不可分操作）を提供し、ミューテックスを使用せずに共有変数への安全なアクセスを可能にします。atomic.StoreUint32やatomic.LoadUint32などが使用されています。
技術的詳細
このコミットは、src/pkg/runtime/chan_test.go に TestChan, TestSelfSelect, TestSelectStress という3つの新しいテスト関数を追加し、既存の TestPseudoRandomSend を修正しています。これらのテストは、Goのチャネルとselectステートメントの様々な挙動を、異なるチャネル容量（バッファサイズ）と並行条件下で検証することを目的としています。
TestChan 関数
この関数は、チャネルの基本的な動作を、バッファなしチャネル（容量0）から大きなバッファありチャネル（容量 N-1 まで）まで、様々な容量でテストします。
- 空のチャネルからの受信ブロック:
- バッファなし/ありチャネルから値を受信しようとするゴルーチンが、値が送信されるまでブロックすることを確認します。
selectのdefault句を使用して、非ブロック受信がすぐに失敗することを確認します。
- 満杯のチャネルへの送信ブロック:
- バッファありチャネルが満杯の状態で値の送信を試みるゴルーチンがブロックすることを確認します。
selectのdefault句を使用して、非ブロック送信がすぐに失敗することを確認します。
- クローズされたチャネルからの受信:
- チャネルがクローズされた後、バッファ内のすべての値が受信された後に、ゼロ値と
ok=falseが返されることを確認します。
- チャネルがクローズされた後、バッファ内のすべての値が受信された後に、ゼロ値と
- クローズによる受信のアンブロック:
- 受信を待機しているゴルーチンが、チャネルがクローズされることでアンブロックされ、ゼロ値と
ok=falseを受け取ることを確認します。
- 受信を待機しているゴルーチンが、チャネルがクローズされることでアンブロックされ、ゼロ値と
- FIFO順序の検証:
- 単一の送信ゴルーチンと単一の受信ゴルーチンで、チャネルがFIFO（First-In, First-Out）順序を維持していることを確認します。
- 複数の送信ゴルーチンと複数の受信ゴルーチン（それぞれ4つ）を使用して、大量の整数（1000個）を送信し、すべての値が正しく受信され、各値が期待される回数（送信ゴルーチンの数）だけ受信されていることを確認します。これは、チャネルが並行環境下でもデータの整合性を保つことを保証します。
len()とcap()の検証:- チャネルの
len()（現在の要素数）とcap()（容量）が、チャネルの作成時と要素の送受信時に正しく更新されることを確認します。
- チャネルの
TestSelfSelect 関数
このテストは、select ステートメント内で同じチャネルに対して送受信操作を同時に行う場合の挙動を検証します。これは、デッドロックやクラッシュが発生しないことを保証するための重要なテストです。
- バッファなしチャネル（容量0）とバッファありチャネル（容量10）の両方でテストを実行します。
- 2つのゴルーチンが、それぞれ1000回ループし、
selectステートメント内で同じチャネルへの送信と受信を交互に試みます。 - 特に、バッファなしチャネルの場合に、送信と受信が同じゴルーチン内で同時に発生しないように（
self receiveとなるような状況を避けるように）注意深くテストが設計されています。これは、バッファなしチャネルでは送信と受信が同期的に行われるため、同じゴルーチンが送信と受信の両方を同時に行おうとするとデッドロックする可能性があるためです。
TestSelectStress 関数
このテストは、複数のチャネルと複数のゴルーチンが複雑に相互作用するストレスシナリオで、select ステートメントの堅牢性を検証します。
- 異なる容量の4つのチャネル（バッファなし、バッファあり）を使用します。
- 合計10個のゴルーチンが参加します。
- 4つのゴルーチンが、それぞれのチャネルに
N個の値を送信します。 - 4つのゴルーチンが、それぞれのチャネルから
N個の値を受信します。 - 1つのゴルーチンが、単一の
selectステートメント内で4つのチャネルすべてにN個の値を送信します。 - 1つのゴルーチンが、単一の
selectステートメント内で4つのチャネルすべてからN個の値を受信します。
- 4つのゴルーチンが、それぞれのチャネルに
- これらのゴルーチンがランタイムでカオス的に相互作用する中で、全体としてデッドロックが発生しないことを保証します。
selectステートメントのcase句でチャネルがnilに設定されることで、特定のチャネルからの送受信が完了した後にそのチャネルがselectの対象から外れるように制御されています。これにより、すべての値が最終的に送受信されることが保証されます。
TestPseudoRandomSend 関数の修正
既存の TestPseudoRandomSend 関数も修正されています。このテストは、select ステートメントが複数の準備ができた case 句の中からランダムに選択するという性質を検証するものです。
- 元のテストでは、バッファなしチャネルのみを対象としていましたが、修正後はバッファなしチャネル（容量0）とバッファありチャネル（容量
n）の両方でテストを実行するようになりました。 selectステートメント内でc <- 1とc <- 0のどちらかを送信する操作をn回繰り返します。- 受信された値の0と1の分布が、ある程度のランダム性（擬似ランダム性）を持っていることを確認します。具体的には、0と1の数がそれぞれ全体の10%より多く、かつ90%より少ないことを期待します。これにより、
selectが特定のcaseに偏ることなく、公平に選択を行っていることを検証します。
これらのテストの追加と修正により、Goランタイムのチャネル実装が、より多様な並行シナリオとエッジケースに対して堅牢であることが保証されます。
コアとなるコードの変更箇所
このコミットの主要な変更は、src/pkg/runtime/chan_test.go ファイルへの追加と修正です。
--- a/src/pkg/runtime/chan_test.go
+++ b/src/pkg/runtime/chan_test.go
@@ -9,8 +9,327 @@ import (
"sync"
"sync/atomic"
"testing"
+ "time"
)
+func TestChan(t *testing.T) {
+ defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(4))
+ N := 200
+ if testing.Short() {
+ N = 20
+ }
+ for chanCap := 0; chanCap < N; chanCap++ {
+ {
+ // Ensure that receive from empty chan blocks.
+ c := make(chan int, chanCap)
+ recv1 := false
+ go func() {
+ _ = <-c
+ recv1 = true
+ }()
+ recv2 := false
+ go func() {
+ _, _ = <-c
+ recv2 = true
+ }()
+ time.Sleep(time.Millisecond)
+ if recv1 || recv2 {
+ t.Fatalf("chan[%d]: receive from empty chan", chanCap)
+ }
+ // Ensure that non-blocking receive does not block.
+ select {
+ case _ = <-c:
+ t.Fatalf("chan[%d]: receive from empty chan", chanCap)
+ default:
+ }
+ select {
+ case _, _ = <-c:
+ t.Fatalf("chan[%d]: receive from empty chan", chanCap)
+ default:
+ }
+ c <- 0
+ c <- 0
+ }
+
+ {
+ // Ensure that send to full chan blocks.
+ c := make(chan int, chanCap)
+ for i := 0; i < chanCap; i++ {
+ c <- i
+ }
+ sent := uint32(0)
+ go func() {
+ c <- 0
+ atomic.StoreUint32(&sent, 1)
+ }()
+ time.Sleep(time.Millisecond)
+ if atomic.LoadUint32(&sent) != 0 {
+ t.Fatalf("chan[%d]: send to full chan", chanCap)
+ }
+ // Ensure that non-blocking send does not block.
+ select {
+ case c <- 0:
+ t.Fatalf("chan[%d]: send to full chan", chanCap)
+ default:
+ }
+ <-c
+ }
+
+ {
+ // Ensure that we receive 0 from closed chan.
+ c := make(chan int, chanCap)
+ for i := 0; i < chanCap; i++ {
+ c <- i
+ }
+ close(c)
+ for i := 0; i < chanCap; i++ {
+ v := <-c
+ if v != i {
+ t.Fatalf("chan[%d]: received %v, expected %v", chanCap, v, i)
+ }
+ }
+ if v := <-c; v != 0 {
+ t.Fatalf("chan[%d]: received %v, expected %v", chanCap, v, 0)
+ }
+ if v, ok := <-c; v != 0 || ok {
+ t.Fatalf("chan[%d]: received %v/%v, expected %v/%v", chanCap, v, ok, 0, false)
+ }
+ }
+
+ {
+ // Ensure that close unblocks receive.
+ c := make(chan int, chanCap)
+ done := make(chan bool)
+ go func() {
+ v, ok := <-c
+ done <- v == 0 && ok == false
+ }()
+ time.Sleep(time.Millisecond)
+ close(c)
+ if !<-done {
+ t.Fatalf("chan[%d]: received non zero from closed chan", chanCap)
+ }
+ }
+
+ {
+ // Send 100 integers,
+ // ensure that we receive them non-corrupted in FIFO order.
+ c := make(chan int, chanCap)
+ go func() {
+ for i := 0; i < 100; i++ {
+ c <- i
+ }
+ }()
+ for i := 0; i < 100; i++ {
+ v := <-c
+ if v != i {
+ t.Fatalf("chan[%d]: received %v, expected %v", chanCap, v, i)
+ }
+ }
+
+ // Same, but using recv2.
+ go func() {
+ for i := 0; i < 100; i++ {
+ c <- i
+ }
+ }()
+ for i := 0; i < 100; i++ {
+ v, ok := <-c
+ if !ok {
+ t.Fatalf("chan[%d]: receive failed, expected %v", n, i)
+ }
+ if v != i {
+ t.Fatalf("chan[%d]: received %v, expected %v", n, v, i)
+ }
+ }
+
+ // Send 1000 integers in 4 goroutines,
+ // ensure that we receive what we send.
+ const P = 4
+ const L = 1000
+ for p := 0; p < P; p++ {
+ go func() {
+ for i := 0; i < L; i++ {
+ c <- i
+ }
+ }()
+ }
+ done := make(chan map[int]int)
+ for p := 0; p < P; p++ {
+ go func() {
+ recv := make(map[int]int)
+ for i := 0; i < L; i++ {
+ v := <-c
+ recv[v] = recv[v] + 1
+ }
+ done <- recv
+ }()
+ }
+ recv := make(map[int]int)
+ for p := 0; p < P; p++ {
+ for k, v := range <-done {
+ recv[k] = recv[k] + v
+ }
+ }
+ if len(recv) != L {
+ t.Fatalf("chan[%d]: received %v values, expected %v", n, len(recv), L)
+ }
+ for _, v := range recv {
+ if v != P {
+ t.Fatalf("chan[%d]: received %v values, expected %v", n, v, P)
+ }
+ }
+ }
+
+ {
+ // Test len/cap.
+ c := make(chan int, chanCap)
+ if len(c) != 0 || cap(c) != chanCap {
+ t.Fatalf("chan[%d]: bad len/cap, expect %v/%v, got %v/%v", chanCap, 0, chanCap, len(c), cap(c))
+ }
+ for i := 0; i < chanCap; i++ {
+ c <- i
+ }
+ if len(c) != chanCap || cap(c) != chanCap {
+ t.Fatalf("chan[%d]: bad len/cap, expect %v/%v, got %v/%v", chanCap, chanCap, chanCap, len(c), cap(c))
+ }
+ }
+
+ }
+}
+
+func TestSelfSelect(t *testing.T) {
+ // Ensure that send/recv on the same chan in select
+ // does not crash nor deadlock.
+ defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(2))
+ for _, chanCap := range []int{0, 10} {
+ var wg sync.WaitGroup
+ wg.Add(2)
+ c := make(chan int, chanCap)
+ for p := 0; p < 2; p++ {
+ p := p
+ go func() {
+ defer wg.Done()
+ for i := 0; i < 1000; i++ {
+ if p == 0 || i%2 == 0 {
+ select {
+ case c <- p:
+ case v := <-c:
+ if chanCap == 0 && v == p {
+ t.Fatalf("self receive")
+ }
+ }
+ } else {
+ select {
+ case v := <-c:
+ if chanCap == 0 && v == p {
+ t.Fatalf("self receive")
+ }
+ case c <- p:
+ }
+ }
+ }
+ }()
+ }
+ wg.Wait()
+ }
+}
+
+func TestSelectStress(t *testing.T) {
+ defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(10))
+ var c [4]chan int
+ c[0] = make(chan int)
+ c[1] = make(chan int)
+ c[2] = make(chan int, 2)
+ c[3] = make(chan int, 3)
+ N := int(1e5)
+ if testing.Short() {
+ N /= 10
+ }
+ // There are 4 goroutines that send N values on each of the chans,
+ // + 4 goroutines that receive N values on each of the chans,
+ // + 1 goroutine that sends N values on each of the chans in a single select,
+ // + 1 goroutine that receives N values on each of the chans in a single select.
+ // All these sends, receives and selects interact chaotically at runtime,
+ // but we are careful that this whole construct does not deadlock.
+ var wg sync.WaitGroup
+ wg.Add(10)
+ for k := 0; k < 4; k++ {
+ k := k
+ go func() {
+ for i := 0; i < N; i++ {
+ c[k] <- 0
+ }
+ wg.Done()
+ }()
+ go func() {
+ for i := 0; i < N; i++ {
+ <-c[k]
+ }
+ wg.Done()
+ }()
+ }
+ go func() {
+ var n [4]int
+ c1 := c
+ for i := 0; i < 4*N; i++ {
+ select {
+ case c1[3] <- 0:
+ n[3]++
+ if n[3] == N {
+ c1[3] = nil
+ }
+ case c1[2] <- 0:
+ n[2]++
+ if n[2] == N {
+ c1[2] = nil
+ }
+ case c1[0] <- 0:
+ n[0]++
+ if n[0] == N {
+ c1[0] = nil
+ }
+ case c1[1] <- 0:
+ n[1]++
+ if n[1] == N {
+ c1[1] = nil
+ }
+ }
+ }
+ wg.Done()
+ }()
+ go func() {
+ var n [4]int
+ c1 := c
+ for i := 0; i < 4*N; i++ {
+ select {
+ case <-c1[0]:
+ n[0]++
+ if n[0] == N {
+ c1[0] = nil
+ }
+ case <-c1[1]:
+ n[1]++
+ if n[1] == N {
+ c1[1] = nil
+ }
+ case <-c1[2]:
+ n[2]++
+ if n[2] == N {
+ c1[2] = nil
+ }
+ case <-c1[3]:
+ n[3]++
+ if n[3] == N {
+ c1[3] = nil
+ }
+ }
+ }
+ wg.Done()
+ }()
+ wg.Wait()
+}
+
func TestChanSendInterface(t *testing.T) {
type mt struct{}
m := &mt{}
@@ -29,34 +348,35 @@ func TestChanSendInterface(t *testing.T) {
func TestPseudoRandomSend(t *testing.T) {
n := 100
- c := make(chan int)
- l := make([]int, n)
- var m sync.Mutex
- m.Lock()
- go func() {
+ for _, chanCap := range []int{0, n} {
+ c := make(chan int, chanCap)
+ l := make([]int, n)
+ var m sync.Mutex
+ m.Lock()
+ go func() {
+ for i := 0; i < n; i++ {
+ runtime.Gosched()
+ l[i] = <-c
+ }
+ m.Unlock()
+ }()
for i := 0; i < n; i++ {
- runtime.Gosched()
- l[i] = <-c
+ select {
+ case c <- 1:
+ case c <- 0:
+ }
}
- m.Unlock()
- }()
- for i := 0; i < n; i++ {
- select {\n- case c <- 0:\n- case c <- 1:\n+ m.Lock() // wait
+ m.Lock() // wait
}
- }
- m.Lock() // wait
- n0 := 0
- n1 := 0
- for _, i := range l {\n- n0 += (i + 1) % 2\n- n1 += i\n- if n0 > n/10 && n1 > n/10 {\n- return\n+ n0 := 0
+ n1 := 0
+ for _, i := range l {
+ n0 += (i + 1) % 2
+ n1 += i
+ }
+ if n0 <= n/10 || n1 <= n/10 {
+ t.Errorf("Want pseudorandom, got %d zeros and %d ones (chan cap %d)", n0, n1, chanCap)
}
}
-\tt.Errorf("Want pseudo random, got %d zeros and %d ones", n0, n1)\n }\n \n func TestMultiConsumer(t *testing.T) {\n```
## コアとなるコードの解説
このコミットは、Goのランタイムパッケージ内のチャネルテストファイル `src/pkg/runtime/chan_test.go` に大幅な変更を加えています。
1. **`TestChan` 関数の追加**:
* この関数は、チャネルの基本的な動作を網羅的にテストします。
* `for chanCap := 0; chanCap < N; chanCap++` ループにより、バッファなしチャネル（`chanCap = 0`）から、様々なサイズのバッファありチャネルまで、広範囲のチャネル容量でテストが実行されます。これにより、チャネルのバッファリング挙動に依存する潜在的なバグが発見されやすくなります。
* 各テストブロックは、空のチャネルからの受信ブロック、満杯のチャネルへの送信ブロック、クローズされたチャネルからの受信、クローズによる受信のアンブロック、FIFO順序の検証、`len`/`cap` の検証など、チャネルの主要な機能とエッジケースをカバーしています。
* 特に、複数のゴルーチンが同時にチャネルに送受信を行うストレスシナリオ（"Send 1000 integers in 4 goroutines" のセクション）は、並行環境下でのチャネルの堅牢性を確認するために重要です。`map[int]int` を使用して受信した値の数をカウントし、すべての値が期待通りに受信されたことを検証しています。
2. **`TestSelfSelect` 関数の追加**:
* この関数は、`select` ステートメント内で同じチャネルに対して送受信操作を同時に行うという、より複雑なシナリオをテストします。
* `defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(2))` は、テストが2つのOSスレッドで実行されるように設定し、並行処理の競合条件をより顕著にする可能性があります。
* `if chanCap == 0 && v == p { t.Fatalf("self receive") }` のチェックは、バッファなしチャネルにおいて、送信と受信が同じゴルーチン内で発生してしまう（自己受信）というデッドロックにつながる可能性のある状況を検出します。これは、バッファなしチャネルの同期的な性質を考慮した重要なテストです。
3. **`TestSelectStress` 関数の追加**:
* この関数は、複数のチャネルと多数のゴルーチンが複雑に相互作用する、高負荷な環境下での `select` ステートメントの動作を検証します。
* `defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(10))` は、テストが最大10個のOSスレッドで実行されるように設定し、より多くの並行性を導入します。
* 異なる容量の4つのチャネルが用意され、合計10個のゴルーチンがこれらのチャネルに対して送受信操作を行います。
* 特に注目すべきは、`select` ステートメント内でチャネル変数を `nil` に設定するパターンです（例: `c1[3] = nil`）。これは、特定のチャネルからの送受信が完了した後に、そのチャネルを `select` の対象から外すためのGoのイディオムです。これにより、テストがデッドロックすることなく、すべての期待される送受信操作が完了することを保証します。
4. **`TestPseudoRandomSend` 関数の修正**:
* この既存のテストは、`select` ステートメントが複数の準備ができた `case` からランダムに選択するという性質を検証するものです。
* 修正により、バッファなしチャネルだけでなく、バッファありチャネル（`chanCap = n`）でもテストが実行されるようになりました。これにより、バッファリングの有無に関わらず `select` のランダム選択挙動が維持されることを確認します。
* `if n0 <= n/10 || n1 <= n/10` という条件は、0と1の受信数が極端に偏っていないか（擬似ランダム性が保たれているか）をチェックします。
これらの変更は、Goランタイムのチャネル実装の堅牢性を大幅に向上させ、並行プログラミングにおけるGoの信頼性を高める上で重要な役割を果たします。特に、様々なチャネル容量、複雑な `select` の相互作用、および高負荷な並行シナリオをカバーすることで、Goの並行プリミティブの安定性が保証されます。
## 関連リンク
* Go言語のチャネルに関する公式ドキュメント: [https://go.dev/tour/concurrency/2](https://go.dev/tour/concurrency/2)
* Go言語の `select` ステートメントに関する公式ドキュメント: [https://go.dev/tour/concurrency/5](https://go.dev/tour/concurrency/5)
* Go言語のテストに関する公式ドキュメント: [https://go.dev/doc/tutorial/add-tests](https://go.dev/doc/tutorial/add-tests)
* Go言語の `sync` パッケージ: [https://pkg.go.dev/sync](https://pkg.go.dev/sync)
* Go言語の `sync/atomic` パッケージ: [https://pkg.go.dev/sync/atomic](https://pkg.go.dev/sync/atomic)
## 参考にした情報源リンク
* Go言語の公式ドキュメント
* Go言語のソースコード（特に `src/runtime/chan.go` や `src/runtime/select.go` など、チャネルと `select` の実装に関するファイル）
* Go言語のテストに関する一般的なプラクティスと記事
* コミットメッセージに記載されている Go Gerrit の変更リスト: [https://golang.org/cl/57390043](https://golang.org/cl/57390043)