Go 知识chan
- 1. 基本知识
- 1.1 定义
- 1.2 操作
- 1.3 操作限定
- 1.4 chan 读写
- 2. 原理
- 2.1 数据结构
- 2.2 环形队列
- 2.3 等待队列
- 2.4 类型消息
- 2.5 读写数据
- 2.6 关闭chan
- 3. 使用
- 3.1 操作符使用
- 3.2 select
- 3.3 for-range
https://a18792721831.github.io/
1. 基本知识
chan是go里面里面提供的语言层面的协程间的通信方式，用于并发通信。
1.1 定义
- 变量声明:
var ch chan int // 声明一个int型的chan
这种方式声明的chan，值为nil。并且每一种chan只能有一种类型。 - make声明:
ch1 := make(chan int)// 无缓存的chan，ch2 := make(chan int, 4)// 有缓冲的chan
1.2 操作
操作符<-表示数据流向，当chan在<-左边，表示数据流向chan，也就是向chan写入数据；当chan在<-右边，表示数据流出chan，
也就是从chan读取数据。
func TestChanOne(t *testing.T) {
var ch chan int
ch = make(chan int) // 无缓冲chan
go func() { // 创建一个协程，不断从chan中读取数据
<-ch
}()
ch <- 1 // 写入数据，因为没有缓冲，如果没有上面那句，这句会阻塞
var ch1 chan int
ch1 = make(chan int, 1) // 有缓冲chan
ch1 <- 2 // 因为有缓存，所以这句不会阻塞，但是因为缓冲长度是1，所以在写入就会阻塞
fmt.Printf("len=%d, cap=%d\n", len(ch1), cap(ch1))
fmt.Println(<-ch1) // 读取数据，因为有缓冲，并且有数据，所以不会阻塞
}
执行结果：
1.3 操作限定
默认的chan为双向可读写，chan在函数间传递的时候，可以使用操作符限制chan的读写。
func ChanRW(ch chan int) {
ch <- 1
<-ch
}
func ChanR(ch <-chan int) {
ch <- 1
<-ch
}
func ChanW(ch chan<- int) {
ch <- 1
<-ch
}
1.4 chan 读写
chan无缓冲时，从chan读取数据会阻塞，直到有协程向chan写入数据。向chan写入数据也会阻塞，直到有协程读取数据。
chan有缓冲时，从chan读取数据，如果缓冲区中没有数据，那么也会阻塞，直到有协程写入数据。向chan写入数据，如果缓冲区已经满了，也会阻塞，直到有协程从chan中读取数据。
对于nil的chan,不管是读还是写，都是永久阻塞。 – 这个一定注意。
使用内置函数close可以关闭chan，尝试向关闭的chan写入数据会触发panic，但是仍然可以读取。
chan读取最多可以给两个变量赋值:
i := <- ch
j, ok := <- ch
第一个变量表示读取的值，第二个变量表示是否成功读取了数据。第二个变量不表示chan是否关闭。
对于关闭的有缓冲的chan存在两种情况：1. 缓冲区中没有数据; 2. 缓冲区中有数据。
对于有缓冲的chan并且用内置函数close进行关闭，在继续读取，针对缓冲区中没有数据，读取的第一个值是该类型的零值，第二个值为false，表示没有成功读取数据。
如果缓冲区中存在数据，那么第一个值是缓冲区中的第一个数据，第二个值是true，表示正确读取到数据。
也就是说，只有缓冲区中没有数据了，第二个值才能代表chan已经关闭。
当chan没有缓冲区的时候，第二个值可以认为是chan的关闭状态。
2. 原理
2.1 数据结构
在源码包的src/runtime/chan.go中定义了chan的结构：
type hchan struct {
qcount uint // 当前队列中剩余的元素个数
dataqsiz uint // 环形队列的长度，即可以存放的元素个数
buf unsafe.Pointer // 环形队列指针
elemsize uint16 // 每个元素的大小
closed uint32 // 关闭状态
elemtype *_type // 元素类型
sendx uint // 写入位置
recvx uint // 读取位置
recvq waitq // 阻塞读协程队列
sendq waitq // 阻塞写协程队列
lock mutex // 互斥锁
}
可以看出，一个chan基本上由数据缓冲，类型信息，和协程等待队列组成。
2.2 环形队列
环形队列主要是存储缓冲数据的，其实实现一个缓冲队列非常简单，只需要一个数组就能实现，每次数组指针到达最后一个元素，那么就重置为0即可。
var data []int
data = make([]int, 10)
for i := 0; i < 100; i++ {
data[i] = i
if i == len(data)-1 {
i = 0
}
}
上面的if就是实现了环形队列，所以名字叫做环形队列，实际上可能是线性的结构。
在chan中使用双指针实现读取和写入数据，读指针表示读取的元素位置，写指针表示写入的元素位置。
当读指针等于写指针的时候，表示数据读取完毕，整个队列为空。
当写指针等于读指针的时候，表示队列满，无法写入。
2.3 等待队列
因为同一个chan可以传给多个协程，就会出现多个协程等待读取的情况；对于写数据也是相同的，那么此时就会根据先后顺序，组成等待队列，等待的协程组成了读阻塞队列和写阻塞队列。
当对chan进行写操作，那么唤醒读队列的协程；当对chan进行读操作，那么唤醒写队列的协程。
对于chan进行写操作，如果读协程队列为空，那么写操作阻塞；对于chan进行读操作，如果写协程队列为空，那么读操作阻塞。
需要注意，上述情况还有一个附件条件：无缓冲chan，如果是有缓冲chan，那么对于写操作，缓冲区满，对于读操作，缓冲区空。
2.4 类型消息
在chan的定义中，保存了类型消息和类型长度，类型消息主要是传递过程中赋值，类型长度主要是计算缓冲区中元素的位置。
2.5 读写数据
对于chan读写数据，实际上就是数据进入缓冲区和读出缓冲区的操作。
在实现上则存在一定的技巧：
写入数据时，如果读协程等待队列不为空，那么直接将数据给读协程等待队列的第一个协程即可，不进行数据缓冲区的数据写入，然后在唤醒，最后读取的操作，避免了数据的额外处理。
同样的，读取数据时，需要甄别一下，因为chan本质上是队列，需要符合先入先出的规则，在写入数据时，因为chan为空，所以不管有没有缓冲区，都可以直接将数据交给等待的读取协程。
但是在读取数据的时候，如果存在缓冲区，那么就必须从缓冲区中读取，读取数据后，环形写入协程等待队列，将数据写入缓冲区的队尾。
只有无缓冲区的chan，才可以直接从写等待协程队列中唤醒协程，并将数据直接交给读取协程。
2.6 关闭chan
关闭chan的时候，会将读等待队列和写等待队列的全部协程都唤醒。
对于读等待的协程，赋值该类型的零值，并且将第二个值赋值为false。
需要注意，对于chan，不会同时既存在读等待队列协程，又存在写等待队列协程。(长时间同时，瞬时的同时可能存在)
对于写等待的协程，直接触发panic，向close的chan写入数据，直接panic。
除此之外，这些操作也会panic:
- 关闭nil的chan
- 关闭已经关闭的chan
- 向已经关闭的chan写入数据
3. 使用
3.1 操作符使用
使用<-进行操作，同时也可以限制在当前函数范围内chan的操作方式，读还是写，还是读写。
3.2 select
对于chan的使用，不管是读取还是写入，非常导致阻塞，但是很多时候，我们又不希望整个程序阻塞，因为是并发的，可能当前chan没有数据，但是别的chan可能有数据，那么就可以在等待一个chan的时候，处理其他chan的数据，增加程序的性能。
使用select就可以实现监控多个chan。
sayOne := make(chan string)
sayTwo := make(chan string)
// 每两秒发送 one
go func() {
for {
sayOne <- "one"
time.Sleep(2 * time.Second)
}
}()
// 每两秒发送 two
go func() {
for {
sayTwo <- "tow"
time.Sleep(2 * time.Second)
}
}()
for {
// 如果 select 中的任何 case 都没有触发，那么 select 本身是会阻塞的，直到某个 case 触发
select {
case msg := <-sayOne:
fmt.Println(msg)
case msg := <-sayTwo:
fmt.Println(msg)
// 但是因为 select 触发的 case 是随机的，所以这里可能并不会正确执行第三个case
case <-time.After(10 * time.Second):
return
}
}
要想按照程序10秒后退出，可以使用定时器进行超时退出：
// 设置超时
time.AfterFunc(10*time.Second, func() {
os.Exit(0)
})
除此之外，还可以使用default进行计时，然后进行超时退出操作。
sayOne := make(chan string)
sayTwo := make(chan string)
// 每两秒发送 one
go func() {
for {
sayOne <- "one"
time.Sleep(2 * time.Second)
}
}()
// 每两秒发送 two
go func() {
for {
sayTwo <- "tow"
time.Sleep(2 * time.Second)
}
}()
// 设置超时
//time.AfterFunc(10*time.Second, func() {
// os.Exit(0)
//})
tm := 0
for {
// 如果 select 中的任何 case 都没有触发，那么 select 本身是会阻塞的，直到某个 case 触发
select {
case msg := <-sayOne:
fmt.Println(msg)
case msg := <-sayTwo:
fmt.Println(msg)
// 但是因为 select 触发的 case 是随机的，所以这里可能并不会正确执行第三个case
//case <-time.After(10 * time.Second):
// return
default:
if tm == 10 {
return
}
time.Sleep(time.Second)
tm++
}
}
3.3 for-range
使用<-操作符可以读取数据，除了使用<-操作符，还可以使用for-range进行数据的读取，就像读取一个数组一样。
ch := make(chan int, 10)
for i := 0; i < 10; i++ {
ch <- i
}
for i := range ch {
fmt.Println(i)
}
使用for-range还有个好处，就是读取的数据都是成功的，不用去考虑数据是否读取成功，同时也不用考虑当chan关闭，当chan关闭后，for-range也能正确的处理。
ch := make(chan int, 10)
for i := 0; i < 10; i++ {
ch <- i
}
// 5秒后关闭chan
time.AfterFunc(5*time.Second, func() {
close(ch)
})
// 每一秒读取一个元素
for i := range ch {
fmt.Println(i)
time.Sleep(time.Second)
}
即使第5秒的时候，chan被关闭了，也可以正确的读取全部的数据。
