Golang 運行時（runtime）管理了一種輕量級線程，被叫做 goroutine。創建數十萬級的 goroutine 是沒有問題的。范例：
package main
import (
"fmt"
"time"
)
func say(s string) {
for i := 0; i < 5; i++ {
time.Sleep(100 * time.Millisecond)
fmt.Println(s)
}
}
func main() {
// 開啟一個 goroutine 執行 say 函數
go say("world")
say("hello")
}
我們使用 channel 和 goroutine 通訊。channel 中是一種帶有類型的通道，被用于接收和發送特定類型的值。操作符 <- 被叫做 channel 操作符（這個操作符中箭頭表明了值的流向）：
// 發送 v 到 channel ch
ch <- v
// 接收 channel ch 中的值并賦值給 v
v := <-ch
使用 channel 和 goroutine 通訊能夠避免顯式使用鎖機制，通過 channel 發送和接收值時默認是阻塞的。
通過 make 函數創建 channel：
// int 指定 channel 收發值的類型為 int
ch := make(chan int)
一個完整的例子：
package main
import "fmt"
// 計算數組 a 中所有元素值之和
func sum(a []int, c chan int) {
sum := 0
for _, v := range a {
sum += v
}
// 計算結果發送到 channel c
c <- sum
}
func main() {
a := []int{7, 2, 8, -9, 4, 0}
// 創建 channel c
c := make(chan int)
go sum(a[:len(a)/2], c)
go sum(a[len(a)/2:], c)
// 接收兩個 goroutine 發送的計算結果
x, y := <-c, <-c
fmt.Println(x, y, x+y)
}package main
import "fmt"
// 計算數組 a 中所有元素值之和
func sum(a []int, c chan int) {
sum := 0
for _, v := range a {
sum += v
}
// 計算結果發送到 channel c
c <- sum
}
func main() {
a := []int{7, 2, 8, -9, 4, 0}
// 創建 channel c
c := make(chan int)
go sum(a[:len(a)/2], c)
go sum(a[len(a)/2:], c)
// 接收兩個 goroutine 發送的計算結果
x, y := <-c, <-c
fmt.Println(x, y, x+y)
}
channel 可以帶有一個緩沖區（buffer）來緩存被傳遞的值，向 channel 中發送時只有緩沖區滿的情況下會阻塞，接收 channel 中的值時只有在緩沖區空的情況下阻塞：
package main
import "fmt"
func main() {
// 創建 channel，緩沖區長度為 2
c := make(chan int, 2)
// 由于 channel 的緩沖區長度為 2
// 因此發送不會阻塞
c <- 1
c <- 2
fmt.Println(<-c)
fmt.Println(<-c)
}
發送者可以調用 close 來關閉 channel，接收者可以檢測到 channel 是否被關閉：
// 這里的 ok 為 false 表示已經沒有值可以接收了，并且 channel 被關閉了
v, ok := <-ch
不要向已經關閉的 channel 發送值了（will cause a panic）。
我們可以使用 for range 來接收 channel 中的值：
package main
import "fmt"
func fibonacci(n int, c chan int) {
x, y := 0, 1
for i := 0; i < n; i++ {
c <- x
x, y = y, x+y
}
// 必須要關閉 c
close(c)
}
func main() {
c := make(chan int, 10)
go fibonacci(cap(c), c)
// 這里 for 和 range 組合使用
// 不斷的接收 c 中的值一直到它被關閉
for i := range c {
fmt.Println(i)
}
}
通常來說，我們不需要主動的關閉 channel。但有時候接收者必須被告知已經沒有值可以接收了，這時候主動關閉是必要的，例如終止 for range 循環。
使用 select 語句可以讓一個 goroutine 等待多個通訊操作。select 會阻塞直到某個 case 能夠運行，如果同時存在多個可執行的，那么將隨機選擇一個：
package main
import "fmt"
func fibonacci(c, quit chan int) {
x, y := 0, 1
for {
select {
case c <- x:
x, y = y, x+y
// 控制此線程退出
case <-quit:
fmt.Println("quit")
return
}
}
}
func main() {
c := make(chan int)
quit := make(chan int)
go func() {
for i := 0; i < 10; i++ {
fmt.Println(<-c)
}
quit <- 0
}()
fibonacci(c, quit)
}
select 中的 default 會在沒有任何 case 可執行時執行（類似于 switch）：
package main
import (
"fmt"
"time"
)
func main() {
// 創建一個 tick channel
// 在 100 毫秒后會向 tick channel 中發送當前時間
tick := time.Tick(100 * time.Millisecond)
// 創建一個 boom channel
// 在 500 毫秒后會向 boom channel 中發送當前時間
boom := time.After(500 * time.Millisecond)
for {
select {
case <-tick:
fmt.Println("tick.")
case <-boom:
fmt.Println("BOOM!")
return
default:
fmt.Println(" .")
time.Sleep(50 * time.Millisecond)
}
}
}
