チャネル
パッケージ メイン
「fmt」をインポート
// Slieceとチャネルを扱う関数
FUNC gorooutine1 （S [] INT 、 C ちゃん INT ） {
合計 ：= 0
のため _ 、 V ：= 範囲 S {
和 + = V
}
// < -チャネルに送信
C < - 合計
}
FUNC メイン（） {
S ：= [] INT { 1 、 2 、 3 、 4 、 5 }
//チャネル整数を扱う
C ：= メイク（チャン INT ）
行く gorooutine1 （S 、 Cの）
// < - Cでチャネルから受け取るまで待機
x ：= < -c
fmt 。Println （x ）
}
15
キューのような使い方
- 2つのチャンネルを並列実行しても2つの処理の実行を待つ
パッケージ メイン
「fmt」をインポート
// Slieceとチャネルを扱う関数
FUNC gorooutine1 （S [] INT 、 C ちゃん INT ） {
合計 ：= 0
のため _ 、 V ：= 範囲 S {
和 + = V
}
// < -チャネルに送信
C < - 合計
}
FUNC gorooutine2 （S [] INT 、 C ちゃん INT ） {
合計 ：= 0
のため _ 、 V ：= 範囲 S {
和 + = V
}
// < -チャネルに送信
C < - 和
}
FUNC メイン（） {
S ：= [] INT { 1 、 2 、 3 、 4 、 5 }
//チャネル整数を扱う
C ：= メイク（チャン INT ）
行く gorooutine1 （S 、 C ）
に行く gorooutine2を（S 、 C ）
// <-cでチャネルから受け取るまで待機
x ：= < -c
fmt 。Println （x ）
y ：= < -c
fmt 。Println （y ）
}
15
15
バッファ付きチャネル
パッケージ メイン
「fmt」をインポート
func main （） {
ch ：= make （chan int 、 2 ）
ch < -100
fmt 。Println （len （ch ））
ch < -200
fmt 。Println （len （ch ））
// rangeで
後続場合はcloseしないと次のChannelを呼ぼうとしてエラーになるclose （ch ）
// forで1つづつルーティング
for c ：= range ch {
fmt 。Println （c ）
}
}
1
2
100
200
チャネルの範囲、閉じる
パッケージ メイン
「fmt」をインポート
FUNC goroutine1 （S [] INT 、 C ちゃん INT ） {
合計 ：= 0
のため _ 、 V ：= 範囲 S {
和 + = V
C < - 和
}
//処理完了後は近くを入れる
近い（C ）
}
FUNC メイン（） {
S ：= [] INT { 1 、 2 、 3 、 4 、 5 }
、C ：= メイク（チャン INT 、 lenの（S ））
に行く goroutine1 （S 、 C ）
//チャネルを1回ずつ呼び出します
for i ：= range c {
fmt 。Println （i ）
}
}
1
３
6
10
15
プロデューサーコンシューマー
パッケージ メイン
インポート （
"fmt"
"sync"
"time"
）
func プロデューサー（ch chan int 、 i int ） {
//何か
ch < -i * 2
}
FUNCの 消費者（CH ちゃん INT 、 WG * 同期。WaitGroup ） {
用 I ：= レンジ CH {
FUNC （） {
FMT 。Println （"process" 、 i * 1000 ）
wg 。完了（）
}（）
}
fmt 。Println （"#################################" ）
}
func main （） {
var wg sync 。WaitGroup
ch ：= make （chan int ）
//プロデューサー
for i ：= 0 ; i < 10 ; i ++ {
wg 。add （1 ）
go プロデューサー（ch 、 i ）
}
//消費者
、外出先の 消費者（CH 、 ＆WG ）
WG 。待機（）
クローズ（ch ）
時間。スリープ（2 * 時間。秒）
fmt 。Println （"完了" ）
}
プロセス0
プロセス4000
プロセス2000
プロセス6000
プロセス8000
プロセス10000
プロセス12000
プロセス14000
プロセス16000
プロセス18000
#################################
できた
ファンアウトファンイン
パッケージ メイン
「fmt」をインポート
func producer （first chan int ） {
defer close （first ）
for i ：= 0 ; i < 10 ; i ++ {
最初 < -i
}
}
func multi2 （first chan int 、 second chan int ） {
defer close （second ）
for i ：= range first {
// 1 * 2 = 2
// 2 * 2 = 4
second < -i * 2
}
}
func multi4 （second chan int 、 third chan int ） {
defer close （third ）
for i ：= range second {
// 2 * 4 = 8
// 4 * 4 = 4
third < -i * 4
}
}
func main （） {
最初 ：= make （chan int ）
2番目 ：= make （chan int ）
3番目 ：= make （chan int ）
go プロデューサー（最初）
go multi2 （最初、 2番目）
go multi4 （2番目、 3番目）
for result ：= range third {
fmt 。Println （結果）
}
}
0
8
16
24
32
40
48
56
64
72
選択する
パッケージ メイン
インポート （
"fmt"
"time"
）
func goroutine1 （ch chan string ） {
for {
ch <- "packat from 1"
time 。スリープ（3 * 時間。秒）
}
}
func goroutine2 （ch chan string ） {
for {
ch <- "packat from 2"
time 。スリープ（1 * 時間。秒）
}
}
func main （） {
c1 ：= make （chan string ）
c2 ：= make （chan string ）
go goroutine1 （c1 ）
go goroutine2 （c2 ）
以下のために {
選択 {
ケース MSG1 = - < C1 ：
FMTを。println （MSG1 ）
場合 MSG2 ：= < - C2 ：
FMT 。Println （msg2 ）
}
}
}
1からのpackat
2からのpackat
2からのpackat
2からのpackat
1からのpackat
2からのpackat
2からのpackat
2からのpackat
デフォルトセクション
パッケージ メイン
インポート （
"fmt"
"time"
）
func main （） {
tick ：= time 。ティック（100 * 時間。ミリ秒）
ブーム ：= 時間。後（500 * 時間。ミリ秒）
以下のために {
選択 {
// 100Millisocond毎
場合 - < ダニ：
FMTを。println （"ダニ" ）
// 500Millisocond毎
場合 < - ブーム：
FMT 。Println （"BOOM" ）
// loop終了
return
//それ以外は
ピリオドデフォルト：
fmt 。Println （"。" ）
時間。スリープ（50 * 時間。ミリ秒）
}
}
}
。
。
ダニ、
。
。
ダニ、
。
。
ダニ、
。
。
ダニ、
。
。
ダニ、
ブーム