参考 Go 语言教程 | 菜鸟教程 (runoob.com) 做了以下笔记
package main
import (
"fmt"
"time"
)
func main() {
sep := "********************"
testChan()
fmt.Println(sep)
testChanNoBuffer()
fmt.Println(sep)
testChanBuffer()
fmt.Println(sep)
// 类似非递归的循环求法
c := make(chan int, 10)
go fibonacci(cap(c), c)
// range 函数遍历每个从通道接收到的数据,因为 c 在发送完 10 个
// 数据之后就关闭了通道,所以这里我们 range 函数在接收到 10 个数据
// 之后就结束了。如果上面的 c 通道不关闭,那么 range 函数就不
// 会结束,从而在接收第 11 个数据的时候就阻塞了。
for i := range c {
fmt.Println(i)
}
}
// say 主线程的say和子线程的say共享 i 变量
func say(s string, it *uint8) {
for i := 0; i < 5; i++ {
time.Sleep(100 * time.Millisecond)
fmt.Println(i, *it, s)
(*it)++
}
}
func testChan() {
// 开启一个新的运行期线程, 即 goroutine,以一个不同的、新创建的 goroutine 来执行一个函数。
// 同一个程序中的所有 goroutine 共享同一个地址空间
var it uint8 = 0
go say("world", &it)
say("hello", &it)
}
func sum(s []int, c chan int) {
sum := 0
for _, v := range s {
sum += v
}
fmt.Println(time.Now(), "准备发送数据", sum)
c <- sum // 把 sum 发送到通道 c
}
func testChanNoBuffer(){
// 通道可用于两个 goroutine 之间通过传递一个指定类型的值来同步运行和通讯。
// 操作符 <- 用于指定通道的方向,发送或接收。如果未指定方向,则为双向通道。
s := []int{7, 2, 8, -9, 4, 0}
c := make(chan int) // 没有指定缓冲区大小,则无缓冲,同一时间只能放下一个数据。放入一个后除非被取出,否则放不下第二个
go sum(s[:len(s)/2], c) // 0~2(3-1),前3数求和发送给通道
go sum(s[len(s)/2:], c) // 3~5,后3数求和发送给通道
fmt.Println(time.Now(), "准备接收第一个数据")
x := <-c
fmt.Println(time.Now(), "接收到", x)
fmt.Println(time.Now(), "准备接收第二个数据")
y := <-c
fmt.Println(time.Now(), "接收到", y)
//x, y := <-c, <-c // 从通道 c 中接收够2个,不够就阻塞等着2个子线程都发送到通道里 OS的管程?
fmt.Println(x, y, x+y) // 运行多次,可发现 x 和 y 可能互相交换。因为”go“关键字开启的两个求部分和的子线程哪一个先结束不确定,但 x 始终接收的是先结束的那个子线程的数据
}
func testChanBuffer(){
// 缓冲区大小为2
ch := make(chan int, 2)
// 因为 ch 是带缓冲的通道,我们可以同时发送两个数据
// 而不用立刻需要去同步读取数据
ch <- 1
ch <- 2
//ch <- 3 // 大小只有2,不取出而强行放入第3个会造成死锁deadlock,后面的代码不会被执行
// 获取这两个数据
fmt.Println(<-ch)
fmt.Println(<-ch)
//fmt.Println(<-ch)
}
func fibonacci(n int, c chan int) {
x, y := 0, 1
for i := 0; i < n; i++ {
c <- x
x, y = y, x+y // 同时(并行): 0, 1 -> 1, 0+1 = 1, 1
}
close(c)
}