Goroutine，Go 在语言层面对并发编程提供支持，⼀种类似协程，称作 goroutine 的机制。
只需在函数调⽤语句前添加 go 关键字，就可创建并发执行单元。开发人员无需了解任何执行细节，调度器会自动将其安排到合适的系统线程上执行。goroutine 是⼀种非常轻量级的实现，可在单个进程里执行成千上万的并发任务。
事实上，入口函数 main 就以 goroutine 运行。另有与之配套的 channel 类型，用以实现 “以通讯来共享内存” 的 CSP 模式
go func() {
fmt.Println("Hello, World!")
}()
调度器不能保证多个 goroutine 执行次序，且进程退出时不会等待它们结束。默认情况下，进程启动后仅允许一个系统线程服务于 goroutine。可使用环境变量或标准库函数 runtime.GOMAXPROCS 修改，让调度器用多个线程实现多核并行，而不仅仅是并发
func sum(id int) {
var x int64
for i := 0; i < math.MaxUint32; i++ {
x += int64(i)
}
fmt.Println(id, x)
}
func main() {
wg := new(sync.WaitGroup)
wg.Add(2)
for i := 0; i < 2; i++ {
go func(id int) {
defer wg.Done()
sum(id)
}(i)
}
wg.Wait()
}
调用 runtime.Goexit 将立即终止当前 goroutine 执行，调度器确保所有已注册 defer延迟调用被执行
func main() {
wg := new(sync.WaitGroup)
wg.Add(1)
go func() {
defer wg.Done()
defer fmt.Println("A.defer")
func() {
defer fmt.Println("B.defer")
runtime.Goexit() // 终⽌当前 goroutine
fmt.Println("B") // 不会执⾏
}()
fmt.Println("A") // 不会执⾏
}()
wg.Wait()
}
和协程 yield 作用类似，Gosched 让出底层线程，将当前 goroutine 暂停，放回队列等待下次被调度执行
func main() {
wg := new(sync.WaitGroup)
wg.Add(2)
go func() {
defer wg.Done()
for i := 0; i < 6; i++ {
fmt.Println(i)
if i == 3 {
runtime.Gosched() //当i=3时，暂停当前协程
}
}
}()
go func() {
defer wg.Done()
fmt.Println("Hello, World!")
}()
wg.Wait()
}
Channel，引用类型 channel 是 CSP 模式的具体实现，用于多个 goroutine 通讯。其内部实现了同步，确保并发安全。默认为同步模式，需要发送和接收配对。否则会被阻塞，直到另一方准备好后被唤醒
func main() {
data := make(chan int) // 数据交换队列
exit := make(chan bool) // 退出通知
go func() {
for d := range data { // 从队列迭代接收数据，直到 close 。
fmt.Println(d)
}
fmt.Println("recv over.")
exit <- true // 发出退出通知。
}()
data <- 1 // 发送数据。
data <- 2
data <- 3
close(data) // 关闭队列。
fmt.Println("send over.")
fmt.Printf("是否退出:%v", <-exit) // 等待退出通知。
}
异步方式通过判断缓冲区来决定是否阻塞。如果缓冲区已满，发送被阻塞；缓冲区为空，接收被阻塞。通常情况下，异步 channel 可减少排队阻塞，具备更高的效率。但应该考虑使用指针规避大对象拷贝，将多个元素打包，减小缓冲区大小等
func main() {
data := make(chan int, 3) // 缓冲区可以存储 3 个元素
exit := make(chan bool)
data <- 1 // 在缓冲区未满前，不会阻塞。
data <- 2
data <- 3
// 另起一个协程接收通道里面的参数
go func() {
for d := range data { // 在缓冲区未空前，不会阻塞。
fmt.Println(d)
}
exit <- true
}()
data <- 4 // 如果缓冲区已满，阻塞。
data <- 5
close(data)
fmt.Printf("是否退出:%v", <-exit)
}
缓冲区是内部属性，并非类型构成要素
var a, b chan int = make(chan int), make(chan int, 3)
除用 range 外，还可用 ok-idiom 模式判断 channel 是否关闭
for {
if d, ok := <-data; ok {
fmt.Println(d)
} else {
break
}
}
向 closed channel 发送数据引发 panic 错误，接收立即返回零值。而 nil channel，无论收发都会被阻塞。内置函数 len 返回未被读取的缓冲元素数量，cap 返回缓冲区大小
d1 := make(chan int) d2 := make(chan int, 3) d2 <- 1 fmt.Println(len(d1), cap(d1)) // 0 0 fmt.Println(len(d2), cap(d2)) // 1 3
单向，可以将 channel 隐式转换为单向队列，只收或只发
c := make(chan int, 3) var send chan<- int = c // send-only var recv <-chan int = c // receive-only send <- 1 // <-send // Error: receive from send-only type chan<- int <-recv // recv <- 2 // Error: send to receive-only type <-chan int
不能将单向 channel 转换为普通 channel
d := (chan int)(send) // Error: cannot convert type chan<- int to type chan int d := (chan int)(recv) // Error: cannot convert type <-chan int to type chan int
选择，如果需要同时处理多个 channel，可使用 select 语句。它随机选择⼀个可用 channel 做收发操作，或执行 default case
注意：在循环中使用 select default case 需要小心，避免形成洪水
func main() {
// 创建通道，创建协程，接收数据的逻辑
a, b := make(chan int, 3), make(chan int)
go func() {
v, ok, s := 0, false, ""
for {
select { // 随机选择可⽤ channel，接收数据。
case v, ok = <-a:
s = "a"
case v, ok = <-b:
s = "b"
}
if ok {
fmt.Println(s, v)
} else {
os.Exit(0)
}
}
}()
// 创建循环建立发送数据的逻辑
for i := 0; i < 5; i++ {
select { // 随机选择可⽤ channel，发送数据。
case a <- i:
case b <- i:
}
}
close(a)
select {} // 没有可⽤ channel，阻塞 main goroutine。
}
模式，用简单工厂模式打包并发任务和 channel
func NewTest() chan int {
c := make(chan int)
rand.Seed(time.Now().UnixNano()) //设置随机种子
go func() {
time.Sleep(time.Second) //睡眠1秒
c <- rand.Int()
}()
return c
}
func main() {
t := NewTest()
fmt.Println(<-t) // 等待 goroutine 结束返回
}
用 channel 实现信号量 (semaphore)
func main() {
wg := sync.WaitGroup{}
wg.Add(3) //限定协程数
sem := make(chan int, 1)
for i := 0; i < 3; i++ {
go func(id int) {
defer wg.Done()
sem <- 1 // 向 sem 发送数据，阻塞或者成功。
for x := 0; x < 3; x++ {
fmt.Println(id, x)
}
<-sem // 接收数据，使得其他阻塞 goroutine 可以发送数据。
}(i)
}
wg.Wait()
}
用 closed channel 发出退出通知
在这里插入代码片
