本篇文章內容基於go1.14.2分析
golang的chan是一個內置類型，作爲csp編程的核心數據結構，其底層數據結構是一個叫hchan的struct：
type hchan struct {
qcount uint // 隊列中的元素數量
dataqsiz uint // （環形）隊列的大小
buf unsafe.Pointer // 隊列的指針
elemsize uint16 // 元素大小
closed uint32 // 是否已close
elemtype *_type // 元素類型
sendx uint // 環形隊列中，send的位置
recvx uint // 環形隊列中 recv的位置
recvq waitq // 讀取等待隊列
sendq waitq // 發送等待隊列
lock mutex // 互斥鎖
}
如圖所示，chan最核心的部分由一個環形隊列和2個waitq組成，環形隊列用於存放數據（帶緩衝的情況下），waitq用於實現阻塞和恢復goroutine。
chan的相關操作
對chan的操作有：make、讀、寫、close，當然還有select，這裏只討論前面四個操作。
創建 chan
當在代碼中使用make創建chan時，編譯器會根據情況自動替換成makechan64 或者makechan，makechan64 其實還是調用了makechan函數。
func makechan(t *chantype, size int) *hchan {
elem := t.elem
// 確保元素類型的size < 2^16，
if elem.size >= 1<<16 {
throw("makechan: invalid channel element type")
}
// 檢查內存對齊
if hchanSize%maxAlign != 0 || elem.align > maxAlign {
throw("makechan: bad alignment")
}
// 計算緩衝區所需分配內存大小
mem, overflow := math.MulUintptr(elem.size, uintptr(size))
if overflow || mem > maxAlloc-hchanSize || size < 0 {
panic(plainError("makechan: size out of range"))
}
var c *hchan
switch {
case mem == 0:
// 即不帶緩衝區的情況，只需要調用mallocgc分配
c = (*hchan)(mallocgc(hchanSize, nil, true))
// 理解爲空地址
c.buf = c.raceaddr()
case elem.ptrdata == 0:
// 元素類型不包含指針的情況
c = (*hchan)(mallocgc(hchanSize+mem, nil, true))
c.buf = add(unsafe.Pointer(c), hchanSize)
default:
// 默認情況下：包含指針
c = new(hchan)
c.buf = mallocgc(mem, elem, true)
}
c.elemsize = uint16(elem.size)
c.elemtype = elem
c.dataqsiz = uint(size)
if debugChan {
print("makechan: chan=", c, "; elemsize=", elem.size, "; dataqsiz=", size, "\n")
}
return c
}
chan 寫操作
當對chan進行寫入“ch <- interface{}” 時，會被編譯器替換成chansend1函數的調用,最終還是調用了chansend函數：
//elem 是待寫入元素的地址
func chansend1(c *hchan, elem unsafe.Pointer) {
chansend(c, elem, true, getcallerpc())
}
先看看chansend的函數簽名，只需關注ep和block這個兩個參數即可，ep是要寫入數據的地址，block表示是否阻塞式的調用
func chansend(c *hchan, ep unsafe.Pointer, block bool, callerpc uintptr) bool
chansend有以下幾種處理流程：
-
當對一個nil chan進行寫操作時，如果是非阻塞調用，直接返回；否則將當前協程掛起
// chansend 對一個 nil chan發送數據時，如果是非阻塞則直接返回，否則將當前協程掛起 if c == nil { if !block { return false } gopark(nil, nil, waitReasonChanSendNilChan, traceEvGoStop, 2) throw("unreachable") } -
非阻塞模式且chan未close，沒有緩衝區且沒有等待接收或者緩衝區滿的情況下，直接return false。
// 1. 非阻塞模式且chan未close // 2. 沒有緩衝區且沒有等待接收 或者 緩衝區滿的情況下 // 滿足以上條件直接return false if !block && c.closed == 0 && ((c.dataqsiz == 0 && c.recvq.first == nil) || (c.dataqsiz > 0 && c.qcount == c.dataqsiz)) { return false } -
c.recvq中有等待讀的接收者，將其出隊，將數據直接copy給接收者，並喚醒接收者。
// 有等待的接收的goroutine // 出隊，傳遞數據 if sg := c.recvq.dequeue(); sg != nil { // Found a waiting receiver. We pass the value we want to send // directly to the receiver, bypassing the channel buffer (if any). send(c, sg, ep, func() { unlock(&c.lock) }, 3) return true }recvq是一個雙向鏈表，每個sudog會關聯上一個reader（被阻塞的g）
![]()
當sudog出隊後，會調用send方法，通過sendDirect 實現數據在兩個地址之間拷貝，最後調用goready喚醒reader（被阻塞的g）
func send(c *hchan, sg *sudog, ep unsafe.Pointer, unlockf func(), skip int) { // ... 剔除無關代碼 if sg.elem != nil { // 直接將數據拷貝到變量ep所在的地址 sendDirect(c.elemtype, sg, ep) sg.elem = nil } gp := sg.g unlockf() gp.param = unsafe.Pointer(sg) if sg.releasetime != 0 { sg.releasetime = cputicks() } //將reader的goroutine喚起 goready(gp, skip+1) } -
緩衝區未滿的情況下，數據放入環形緩衝區即可。
// 緩衝區未滿 // 將數據放到緩衝區 if c.qcount < c.dataqsiz { // Space is available in the channel buffer. Enqueue the element to send. // 存放位置 qp := chanbuf(c, c.sendx) if raceenabled { raceacquire(qp) racerelease(qp) } typedmemmove(c.elemtype, qp, ep) // 指針自增 c.sendx++ if c.sendx == c.dataqsiz { c.sendx = 0 } c.qcount++ unlock(&c.lock) return true }
-
緩衝區已滿，阻塞模式下關聯一個sudog數據結構並進入c.sendq隊列，掛起當前協程。
// 阻塞的情況 gp := getg() //拿到當前g mysg := acquireSudog() // 獲取一個sudog mysg.releasetime = 0 if t0 != 0 { mysg.releasetime = -1 mysg.elem = ep //關聯ep，即待寫入的數據地址 mysg.waitlink = nil mysg.g = gp mysg.isSelect = false mysg.c = c gp.waiting = mysg gp.param = nil c.sendq.enqueue(mysg) // 入隊 // Signal to anyone trying to shrink our stack that we're about // to park on a channel. The window between when this G's status // changes and when we set gp.activeStackChans is not safe for // stack shrinking. atomic.Store8(&gp.parkingOnChan, 1) // 將g休眠，讓出cpu // gopark後，需等待reader來喚醒它 gopark(chanparkcommit, unsafe.Pointer(&c.lock), waitReasonChanSend, traceEvGoBlockSend, 2) // 喚醒過後 // Ensure the value being sent is kept alive until the // receiver copies it out. The sudog has a pointer to the // stack object, but sudogs aren't considered as roots of the // stack tracer. // 保持數據不被回收 KeepAlive(ep) // someone woke us up. if mysg != gp.waiting { throw("G waiting list is corrupted") } gp.waiting = nil gp.activeStackChans = false if gp.param == nil { if c.closed == 0 { throw("chansend: spurious wakeup") } panic(plainError("send on closed channel")) } gp.param = nil if mysg.releasetime > 0 { blockevent(mysg.releasetime-t0, 2) } mysg.c = nil releaseSudog(mysg) return true
chan 讀操作
當對chan進行讀操作時，編譯器會替換成 chanrecv1或者chanrecv2函數，最終會調用chanrecv函數處理讀取
// v := <- ch
func chanrecv1(c *hchan, elem unsafe.Pointer) {
chanrecv(c, elem, true)
}
// v, ok := <- ch
func chanrecv2(c *hchan, elem unsafe.Pointer) (received bool) {
_, received = chanrecv(c, elem, true)
return
}
和chansend一樣，chanrecv也是支持非阻塞式的調用
func chanrecv(c *hchan, ep unsafe.Pointer, block bool) (selected, received bool)
chanrecv有以下幾種處理流程：
-
讀nil chan，如果是非阻塞，直接返回；如果是阻塞式，將當前協程掛起。
// 讀阻塞 if c == nil { if !block { return } gopark(nil, nil, waitReasonChanReceiveNilChan, traceEvGoStop, 2) throw("unreachable") } -
非阻塞模式下，沒有緩衝區且沒有等待寫的writer或者緩衝區沒數據，直接返回。
if !block && (c.dataqsiz == 0 && c.sendq.first == nil || c.dataqsiz > 0 && atomic.Loaduint(&c.qcount) == 0) && atomic.Load(&c.closed) == 0 { return } -
chan已經被close，並且隊列中沒有數據時，會將存放值的變量清零，然後返回。
// c已經被close 並且 沒有數據 // 清除ep指針 if c.closed != 0 && c.qcount == 0 { if raceenabled { raceacquire(c.raceaddr()) } unlock(&c.lock) if ep != nil { typedmemclr(c.elemtype, ep) } return true, false } -
sendq中有等待的writer，writer出隊，並調用recv函數
// 從sendq中取出sender if sg := c.sendq.dequeue(); sg != nil { // Found a waiting sender. If buffer is size 0, receive value // directly from sender. Otherwise, receive from head of queue // and add sender's value to the tail of the queue (both map to // the same buffer slot because the queue is full). // 從sender中讀取數據 recv(c, sg, ep, func() { unlock(&c.lock) }, 3) return true, true }![]()
recv在這分兩種處理：如果ch不帶緩衝區的話，直接將writer的sg.elem數據拷貝到ep；如果帶緩衝區的話，此時緩衝區肯定滿了，那麼就從緩衝區隊列頭部取出數據拷貝至ep，然後將writer的sg.elem數據拷貝到緩衝區中，最後喚醒writer（g）
func recv(c *hchan, sg *sudog, ep unsafe.Pointer, unlockf func(), skip int) { // 不帶緩衝區的情況 // 直接copy from sender if c.dataqsiz == 0 { if raceenabled { racesync(c, sg) } if ep != nil { // copy data from sender recvDirect(c.elemtype, sg, ep) } } else { // Queue is full. Take the item at the // head of the queue. Make the sender enqueue // its item at the tail of the queue. Since the // queue is full, those are both the same slot. // 隊列已滿 // 隊列元素出隊 qp := chanbuf(c, c.recvx) if raceenabled { raceacquire(qp) racerelease(qp) raceacquireg(sg.g, qp) racereleaseg(sg.g, qp) } // copy data from queue to receiver // 數據拷貝給ep if ep != nil { typedmemmove(c.elemtype, ep, qp) } // copy data from sender to queue // 將sender的數據拷貝到這個槽中 typedmemmove(c.elemtype, qp, sg.elem) c.recvx++ if c.recvx == c.dataqsiz { c.recvx = 0 } c.sendx = c.recvx // c.sendx = (c.sendx+1) % c.dataqsiz } // 置空 sg.elem = nil gp := sg.g unlockf() gp.param = unsafe.Pointer(sg) if sg.releasetime != 0 { sg.releasetime = cputicks() } // 喚醒sender協程 goready(gp, skip+1) } -
直接從緩衝隊列中讀數。
// 帶緩衝區 if c.qcount > 0 { // Receive directly from queue // 直接buf中取 qp := chanbuf(c, c.recvx) if raceenabled { raceacquire(qp) racerelease(qp) } // 拷貝數據到ep指針 if ep != nil { typedmemmove(c.elemtype, ep, qp) } // 清除qp typedmemclr(c.elemtype, qp) c.recvx++ if c.recvx == c.dataqsiz { c.recvx = 0 } c.qcount-- unlock(&c.lock) return true, true } -
阻塞的情況，緩衝區沒有數據，且沒有writer
// 阻塞 gp := getg() //拿到當前的goroutine mysg := acquireSudog() // 獲取一個sudog mysg.releasetime = 0 if t0 != 0 { mysg.releasetime = -1 } //sudog 關聯 mysg.elem = ep mysg.waitlink = nil gp.waiting = mysg mysg.g = gp mysg.isSelect = false mysg.c = c gp.param = nil c.recvq.enqueue(mysg) //入隊 // Signal to anyone trying to shrink our stack that we're about // to park on a channel. The window between when this G's status // changes and when we set gp.activeStackChans is not safe for // stack shrinking. atomic.Store8(&gp.parkingOnChan, 1) // 掛起當前goroutine，等待writer喚醒 gopark(chanparkcommit, unsafe.Pointer(&c.lock), waitReasonChanReceive, traceEvGoBlockRecv, 2) // 喚醒後 if mysg != gp.waiting { throw("G waiting list is corrupted") } gp.waiting = nil gp.activeStackChans = false if mysg.releasetime > 0 { blockevent(mysg.releasetime-t0, 2) } closed := gp.param == nil gp.param = nil // sudog解除關聯 mysg.c = nil // 釋放sudog releaseSudog(mysg)
close 關閉操作
當close一個chan時，編譯器會替換成對closechan函數的調用，將closed字段置爲1，並將recvq和sendq中的goroutine釋放喚醒，對sendq中未寫入的數據做清除，且writer會發生panic異常。
func closechan(c *hchan) {
if c == nil {
panic(plainError("close of nil channel"))
}
// 加鎖
lock(&c.lock)
// 不可重複close
if c.closed != 0 {
unlock(&c.lock)
panic(plainError("close of closed channel"))
}
if raceenabled {
callerpc := getcallerpc()
racewritepc(c.raceaddr(), callerpc, funcPC(closechan))
racerelease(c.raceaddr())
}
c.closed = 1
var glist gList
// 釋放所有的
for {
// 出隊
sg := c.recvq.dequeue()
if sg == nil {
break
}
// 清零
if sg.elem != nil {
typedmemclr(c.elemtype, sg.elem)
sg.elem = nil
}
if sg.releasetime != 0 {
sg.releasetime = cputicks()
}
gp := sg.g
gp.param = nil
if raceenabled {
raceacquireg(gp, c.raceaddr())
}
glist.push(gp)
}
// 釋放所有writer
for {
// 出隊
sg := c.sendq.dequeue()
if sg == nil {
break
}
// 丟棄數據
sg.elem = nil
if sg.releasetime != 0 {
sg.releasetime = cputicks()
}
gp := sg.g
gp.param = nil
if raceenabled {
raceacquireg(gp, c.raceaddr())
}
glist.push(gp)
}
unlock(&c.lock)
// 喚醒所有g
for !glist.empty() {
gp := glist.pop()
gp.schedlink = 0
goready(gp, 3)
}
}
chan使用小技巧
-
避免read、write一個nil chan
func main() { ch := make(chan int,1) go func() { time.Sleep(1*time.Second) ch = nil }() ch<-1 ch<-1 // 協程直接掛起 } -
從chan中read時，使用帶指示的訪問方式，讀取的時候無法感知到close的關閉
func main() { ch := make(chan int) go func() { ch <- 10 close(ch) }() for { select { // case i, ok := <-ch: // if ok { // break //} case i := <-ch: fmt.Println(i) time.Sleep(100 * time.Millisecond) } } } -
從chan中read時，不要使用已存在變量接收, chan close之後，緩衝區沒有數據的話，使用存在變量讀取時，會將變量清零
func main() { a := 10 ch := make(chan int,1) fmt.Println("before close a is: ", a) // a is 10 close(ch) a = <-ch fmt.Println("after close a is: ", a) // a is 0 }
-
使用select+default可以實現 chan的無阻塞讀取
// 使用select反射包實現無阻塞讀寫 func tryRead(ch chan int) (int, bool) { var cases []reflect.SelectCase caseRead := reflect.SelectCase{ Dir: reflect.SelectRecv, Chan: reflect.ValueOf(ch), } cases = append(cases, caseRead) cases = append(cases, reflect.SelectCase{ Dir: reflect.SelectDefault, }) _, v, ok := reflect.Select(cases) if ok { return (v.Interface()).(int), ok } return 0, ok } func tryWrite(ch chan int, data int) bool { var cases []reflect.SelectCase caseWrite := reflect.SelectCase{ Dir: reflect.SelectSend, Chan: reflect.ValueOf(ch), Send: reflect.ValueOf(data), } cases = append(cases, caseWrite) cases = append(cases, reflect.SelectCase{ Dir: reflect.SelectDefault, }) chosen, _, _ := reflect.Select(cases) return chosen == 0 } // 使用select + default實現無阻塞讀寫 func tryRead2(ch chan int) (int, bool) { select { case v, ok := <-ch: return v, ok default: return 0, false } } func tryWrite2(ch chan int, data int) bool { select { case ch <- data: return true default: return false } }原因是如果select的case中存在default，對chan的讀寫會使用無阻塞的方法
func selectnbsend(c *hchan, elem unsafe.Pointer) (selected bool) { return chansend(c, elem, false, getcallerpc()) } func selectnbrecv(elem unsafe.Pointer, c *hchan) (selected bool) { selected, _ = chanrecv(c, elem, false) return }