共计 5013 个字符，预计需要花费 13 分钟才能阅读完成。
channel 一个类型管道，通过它能够在 goroutine 之间发送和接管音讯。它是 Golang 在语言层面提供的 goroutine 间的通信形式。
家喻户晓，Go 依赖于称为 CSP（Communicating Sequential Processes）的并发模型，通过 Channel 实现这种同步模式。Go 并发的外围哲学是不要通过共享内存进行通信; 相同，通过沟通分享记忆。
上面以简略的示例来演示 Go 如何通过 channel 来实现通信。
package main
import (
"fmt"
"time"
)
func goRoutineA(a <-chan int) {
val := <-a
fmt.Println("goRoutineA received the data", val)
}
func goRoutineB(b chan int) {
val := <-b
fmt.Println("goRoutineB received the data", val)
}
func main() {ch := make(chan int, 3)
go goRoutineA(ch)
go goRoutineB(ch)
ch <- 3
time.Sleep(time.Second * 1)
}
后果为：
goRoutineA received the data 3
下面只是个简略的例子，只输入 goRoutineA，没有执行 goRoutineB，阐明 channel 仅容许被一个 goroutine 读写。
接下来咱们通过源代码分析程序执行过程，在讲之前，如果不理解 go 并发和调度相干常识。请浏览这篇文章
https://github.com/guyan0319/…
说道 channel 这里不得不提通道的构造 hchan。
hchan
源代码在 src/runtime/chan.go
type hchan struct {
qcount uint // total data in the queue
dataqsiz uint // size of the circular queue
buf unsafe.Pointer // points to an array of dataqsiz elements
elemsize uint16
closed uint32
elemtype *_type // element type
sendx uint // send index
recvx uint // receive index
recvq waitq // list of recv waiters
sendq waitq // list of send waiters
// lock protects all fields in hchan, as well as several
// fields in sudogs blocked on this channel.
//
// Do not change another G's status while holding this lock
// (in particular, do not ready a G), as this can deadlock
// with stack shrinking.
lock mutex
}
type waitq struct {
first *sudog
last *sudog
}
阐明：
qcount uint // 以后队列中残余元素个数
dataqsiz uint // 环形队列长度，即缓冲区的大小，即 make（chan T，N），N.
buf unsafe.Pointer // 环形队列指针
elemsize uint16 // 每个元素的大小
closed uint32 // 示意以后通道是否处于敞开状态。创立通道后，该字段设置为 0，即通道关上; 通过调用 close 将其设置为 1，通道敞开。
elemtype *_type // 元素类型，用于数据传递过程中的赋值；
sendx uint 和recvx uint 是环形缓冲区的状态字段，它批示缓冲区的以后索引 – 反对数组，它能够从中发送数据和接收数据。
recvq waitq // 期待读音讯的 goroutine 队列
sendq waitq // 期待写音讯的 goroutine 队列
lock mutex // 互斥锁，为每个读写操作锁定通道，因为发送和接管必须是互斥操作。
这里sudog 代表 goroutine。
创立 channel 有两种，一种是带缓冲的 channel，一种是不带缓冲的 channel
// 带缓冲
ch := make(chan Task, 3)
// 不带缓冲
ch := make(chan int)
这里咱们先探讨带缓冲
ch := make(chan int, 3)
创立通道后的缓冲通道构造
hchan struct {
qcount uint : 0
dataqsiz uint : 3
buf unsafe.Pointer : 0xc00007e0e0
elemsize uint16 : 8
closed uint32 : 0
elemtype *runtime._type : &{
size:8
ptrdata:0
hash:4149441018
tflag:7
align:8
fieldalign:8
kind:130
alg:0x55cdf0
gcdata:0x4d61b4
str:1055
ptrToThis:45152
}
sendx uint : 0
recvx uint : 0
recvq runtime.waitq :
{first:<nil> last:<nil>}
sendq runtime.waitq :
{first:<nil> last:<nil>}
lock runtime.mutex :
{key:0}
}
源代码
func makechan(t *chantype, size int) *hchan {
elem := t.elem
...
}
如果咱们创立一个带 buffer 的 channel，底层的数据模型如下图：
向 channel 写入数据
ch <- 3
底层 hchan 数据流程如图
发送操作概要
1、锁定整个通道构造。
2、确定写入。尝试 recvq 从期待队列中期待 goroutine，而后将元素间接写入 goroutine。
3、如果 recvq 为 Empty，则确定缓冲区是否可用。如果可用，从以后 goroutine 复制数据到缓冲区。
4、如果缓冲区已满，则要 写入的元素将保留在以后正在执行的 goroutine 的构造中，并且以后 goroutine 将在 sendq 中 排队并从运行时挂起。
5、写入实现开释锁。
这里咱们要留神几个属性 buf、sendx、lock 的变动。
流程图
从 channel 读取操作
简直和写入操作雷同
代码
func goRoutineA(a <-chan int) {
val := <-a
fmt.Println("goRoutineA received the data", val)
}
底层 hchan 数据流程如图
这里咱们要留神几个属性 buf、sendx、recvx、lock 的变动。
读取操作概要
1、先获取 channel 全局锁
2、尝试 sendq 从期待队列中获取期待的 goroutine，
3、如有期待的 goroutine，没有缓冲区，取出 goroutine 并读取数据，而后唤醒这个 goroutine，完结读取开释锁。
4、如有期待的 goroutine，且有缓冲区（此时缓冲区已满），从缓冲区队首取出数据，再从 sendq 取出一个 goroutine，将 goroutine 中的数据存入 buf 队尾，完结读取开释锁。
5、如没有期待的 goroutine，且缓冲区有数据，间接读取缓冲区数据，完结读取开释锁。
6、如没有期待的 goroutine，且没有缓冲区或缓冲区为空，将以后的 goroutine 退出 recvq 排队，进入睡眠，期待被写 goroutine 唤醒。完结读取开释锁。
流程图
recvq 和 sendq 构造
recvq 和 sendq 基本上是链表，看起来根本如下
select
select 就是用来监听和 channel 无关的 IO 操作，当 IO 操作产生时，触发相应的动作。
一个简略的示例如下
package main
import (
"fmt"
"time"
)
func goRoutineD(ch chan int, i int) {time.Sleep(time.Second * 3)
ch <- i
}
func goRoutineE(chs chan string, i string) {time.Sleep(time.Second * 3)
chs <- i
}
func main() {ch := make(chan int, 5)
chs := make(chan string, 5)
go goRoutineD(ch, 5)
go goRoutineE(chs, "ok")
select {
case msg := <-ch:
fmt.Println("received the data", msg)
case msgs := <-chs:
fmt.Println("received the data", msgs)
default:
fmt.Println("no data received")
time.Sleep(time.Second * 1)
}
}
运行程序，因为以后工夫没有到 3s，所以 select 抉择 defult
no data received
批改程序，咱们正文掉 default，并多执行几次后果为
received the data 5
received the data ok
received the data ok
received the data ok
select 语句会阻塞，直到监测到一个能够执行的 IO 操作为止，而这里 goRoutineD 和 goRoutineE 睡眠工夫是雷同的，都是 3s，从输入可看出，从 channel 中读出数据的程序是随机的。
再批改代码，goRoutineD 睡眠工夫改成 4s
func goRoutineD(ch chan int, i int) {time.Sleep(time.Second * 4)
ch <- i
}
此时会先执行 goRoutineE，select 抉择 case msgs := <-chs。
range
能够继续从 channel 读取数据，始终到 channel 被敞开，当 channel 中没有数据时会阻塞以后 goroutine，与读 channel 时阻塞解决机制一样。
package main
import (
"fmt"
"time"
)
func goRoutineD(ch chan int, i int) {
for i := 1; i <= 5; i++{ch <- i}
}
func chanRange(chanName chan int) {
for e := range chanName {fmt.Printf("Get element from chan: %d\n", e)
if len(chanName) <= 0 { // 如果现有数据量为 0，跳出循环
break
}
}
}
func main() {ch := make(chan int, 5)
go goRoutineD(ch, 5)
chanRange(ch)
}
后果：
Get element from chan: 1
Get element from chan: 2
Get element from chan: 3
Get element from chan: 4
Get element from chan: 5
死锁（deadlock）
指两个或两个以上的协程的执行过程中，因为竞争资源或因为彼此通信而造成的一种阻塞的景象。
在非缓冲信道若产生只流入不流出，或只流出不流入，就会产生死锁。
上面是一些死锁的例子
1、
package main
func main() {ch := make(chan int)
ch <- 3
}
下面状况，向非缓冲通道写数据会产生阻塞，导致死锁。解决办法创立缓冲区 ch := make(chan int，3)
2、
package main
import ("fmt")
func main() {ch := make(chan int)
fmt.Println(<-ch)
}
向非缓冲通道读取数据会产生阻塞，导致死锁。解决办法开启缓冲区，先向 channel 写入数据。
3、
package main
func main() {ch := make(chan int, 3)
ch <- 3
ch <- 4
ch <- 5
ch <- 6
}
写入数据超过缓冲区数量也会产生死锁。解决办法将写入数据取走。
死锁的状况有很多这里不再赘述。
还有一种状况，向敞开的 channel 写入数据，不会产生死锁，产生 panic。
package main
func main() {ch := make(chan int, 3)
ch <- 1
close(ch)
ch <- 2
}
解决办法别向敞开的 channel 写入数据。
参考：
https://codeburst.io/diving-d…
https://speakerdeck.com/kavya…
https://my.oschina.net/renhc/…
