版权声明：忠于祖国，忠于人民 https://blog.csdn.net/boss2967/article/details/85089889
1. Goroutine
1.1 Go 在语言层面对并发编程提供支持，一种类似协程，称作 goroutine 的机制
- 怎么实现go程呢，只需在函数调用语句前添加 go 关键字，就可创建并发执行单元。开发⼈人员无需了解任何执行细节，调度器会自动将其安排到合适的系统线程上执行。goroutine 是一种⾮非常轻量级的实现，可在单个进程里执行成千上万的并发任务。
- 事实上，入口函数 main 就以 goroutine 运行。另有与之配套的 channel 类型，用以实现 “以通讯来共享内存” 的 CSP 模式。
go func() {
println("Hello, World!")
}()
- 调度器不能保证多个 goroutine 执行次序，且进程退出时不会等待它们结束
- 默认情况下，进程启动后仅允许一个系统线程服务于 goroutine。可使用环境变量或标准库函数 runtime.GOMAXPROCS 修改，让调度器用多个线程实现多核并行，而不仅仅是并发
package main
import (
"fmt"
"runtime"
"sync"
)
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()
}
1.2 和协程 yield 作用类似，Gosched 让出底层线程，将当前 goroutine 暂停，放回队列等待下次被调度执行
package main
import (
"fmt"
"runtime"
"sync"
)
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()
}
}
}()
go func() {
defer wg.Done()
fmt.Println("Hello, World!")
}()
wg.Wait()
}
1.3 Channel
- 引用类型 channel 是 CSP 模式的具体实现，用于多个 goroutine 通讯。其内部实现了同步，确保并发安全
- 默认为同步模式，需要发送和接收配对。否则会被阻塞，直到另一方准备好后被唤醒
package main
import "fmt"
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.")
<-exit // 等待退出通知。
}
1.4 异步方式通过判断缓冲区来决定是否阻塞。如果缓冲区已满，发送被阻塞；缓冲区为空，接收被阻塞。
- 通常情况下，异步 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)
<-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，无论收发都会被阻塞。
1.5 内置函数 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
1.6 单向
- 可以将 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
1.7 选择
- 如果需要同时处理多个 channel，可使用 select 语句。它随机选择一个可用 channel 做收发操作，或执行 default case。
package main
import (
"fmt"
"os"
)
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。
}
- 在循环中使用 select default case 需要小心，避免形成洪水。