ch := make(chan int)
select{
  case <- ch:
  default:
}

// channel
type hchan struct {
    // 循環(huán)隊(duì)列
    qcount   uint           // 通道中數(shù)據(jù)個(gè)數(shù)
    dataqsiz uint           // buf長度
    buf      unsafe.Pointer // 數(shù)組指針
    sendx    uint   // send index
    recvx    uint   // receive index
    elemsize uint16 // 元素大小
    elemtype *_type // 元素類型
    closed   uint32 // 通道關(guān)閉標(biāo)志
    recvq    waitq  // 由雙向鏈表實(shí)現(xiàn)的recv waiters隊(duì)列
    sendq    waitq  // 由雙向鏈表實(shí)現(xiàn)的send waiters隊(duì)列
    lock mutex
}

// 等待隊(duì)列(雙向鏈表)
type waitq struct {
    first *sudog
    last  *sudog
}

// sudog represents a g in a wait list, such as for sending/receiving
// on a channel.
type sudog struct {
    g *g // 等待send或recv的協(xié)程g
    next *sudog // 等待隊(duì)列下一個(gè)結(jié)點(diǎn)next
    prev *sudog // 等待隊(duì)列前一個(gè)結(jié)點(diǎn)prev
    elem unsafe.Pointer // data element (may point to stack)
    success bool // 標(biāo)記協(xié)程g被喚醒是因?yàn)閿?shù)據(jù)傳遞(true)還是channel被關(guān)閉(false)
    c        *hchan // channel
}

func makechan(t *chantype, size int) *hchan {
    elem := t.elem
    // buf數(shù)組所需分配內(nèi)存大小
    mem := elem.size*uintptr(size)
    var c *hchan
    switch {
    case mem == 0:// Unbuffered channels，buf無需內(nèi)存分配
        c = (*hchan)(mallocgc(hchanSize, nil, true))
        // Race detector uses this location for synchronization.
        c.buf = c.raceaddr()
    case elem.ptrdata == 0: // Buffered channels，通道元素類型非指針
        c = (*hchan)(mallocgc(hchanSize+mem, nil, true))
        c.buf = add(unsafe.Pointer(c), hchanSize)
    default:
        // Buffered channels，通道元素類型是指針
        c = new(hchan)
        c.buf = mallocgc(mem, elem, true)
    }
    c.elemsize = uint16(elem.size)
    c.elemtype = elem
    c.dataqsiz = uint(size)
    return c
}

func chansend(c *hchan, ep unsafe.Pointer, block bool, callerpc uintptr) bool {
    // 1.channel為nil
    if c == nil {
        gopark(nil, nil, waitReasonChanSendNilChan, traceEvGoStop, 2)
        throw("unreachable")
    }
    lock(&c.lock) //加鎖
    // 2.如果channel已關(guān)閉，直接panic
    if c.closed != 0 {
        unlock(&c.lock)
        panic(plainError("send on closed channel"))
    }
    // Block on the channel. 
    mysg := acquireSudog()
    c.sendq.enqueue(mysg) // 入sendq等待隊(duì)列
    gopark(chanparkcommit, unsafe.Pointer(&c.lock), waitReasonChanSend, traceEvGoBlockSend, 2)
    closed := !mysg.success // 協(xié)程被喚醒的原因是因?yàn)閿?shù)據(jù)傳遞還是通道被關(guān)閉
    // 3.因channel被關(guān)閉導(dǎo)致阻塞寫協(xié)程被喚醒并panic
    if closed {
        panic(plainError("send on closed channel"))
    }
}

func chansend(c *hchan, ep unsafe.Pointer, block bool, callerpc uintptr) bool {
    lock(&c.lock) //加鎖
    // 1、當(dāng)存在等待接收的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) // 直接把正在發(fā)送的值發(fā)送給等待接收的Goroutine，并將此接收協(xié)程放入可調(diào)度隊(duì)列等待調(diào)度
        return true
    }
}
// send processes a send operation on an empty channel c.
// The value ep sent by the sender is copied to the receiver sg.
// The receiver is then woken up to go on its merry way.
// Channel c must be empty and locked.  send unlocks c with unlockf.
// sg must already be dequeued from c.
// ep must be non-nil and point to the heap or the caller's stack.
func send(c *hchan, sg *sudog, ep unsafe.Pointer, unlockf func(), skip int) {
    // 將ep寫入sg中的elem
    if sg.elem != nil {
         t:=c.elemtype
         dst := sg.elem
         // memmove copies n bytes from "from" to "to".
         memmove(dst, ep, t.size)
         sg.elem = nil // 數(shù)據(jù)已經(jīng)被寫入到<- c變量，因此sg.elem指針可以置空了
    }
    gp := sg.g
    unlockf()
    gp.param = unsafe.Pointer(sg)
    sg.success = true
    // 喚醒receiver協(xié)程gp
    goready(gp, skip+1)
}
// 喚醒receiver協(xié)程gp，將其放入可運(yùn)行隊(duì)列中等待調(diào)度執(zhí)行
func goready(gp *g, traceskip int) {
    systemstack(func() {
        ready(gp, traceskip, true)
    })
}
// Mark gp ready to run.
func ready(gp *g, traceskip int, next bool) {
    status := readgstatus(gp)
    // Mark runnable.
    _g_ := getg()
    mp := acquirem() // disable preemption because it can be holding p in a local var
    // status is Gwaiting or Gscanwaiting, make Grunnable and put on runq
    casgstatus(gp, _Gwaiting, _Grunnable)
    runqput(_g_.m.p.ptr(), gp, next)
    wakep()
    releasem(mp)
}

func chansend(c *hchan, ep unsafe.Pointer, block bool, callerpc uintptr) bool {
    lock(&c.lock) //加鎖
    // 當(dāng)緩沖區(qū)未滿時(shí)
    if c.qcount < c.dataqsiz {
        // Space is available in the channel buffer. Enqueue the element to send.
        qp := chanbuf(c, c.sendx) // 獲取指向緩沖區(qū)數(shù)組中位于sendx位置的元素的指針
        typedmemmove(c.elemtype, qp, ep) // 將當(dāng)前發(fā)送的值拷貝到緩沖區(qū)
        c.sendx++ 
        if c.sendx == c.dataqsiz {
            c.sendx = 0 // 因?yàn)槭茄h(huán)隊(duì)列，sendx等于隊(duì)列長度時(shí)置為0
        }
        c.qcount++
        unlock(&c.lock)
        return true
    }
}

func chansend(c *hchan, ep unsafe.Pointer, block bool, callerpc uintptr) bool {
    lock(&c.lock) //加鎖
    // Block on the channel. 
    // 將當(dāng)前的Goroutine打包成一個(gè)sudog節(jié)點(diǎn)，并加入到阻塞寫隊(duì)列sendq里
    gp := getg()
    mysg := acquireSudog()
    mysg.elem = ep
    mysg.g = gp
    mysg.c = c
    gp.waiting = mysg
    c.sendq.enqueue(mysg) // 入sendq等待隊(duì)列
    // 調(diào)用gopark將當(dāng)前Goroutine設(shè)置為等待狀態(tài)并解鎖，進(jìn)入休眠等待被喚醒，觸發(fā)協(xié)程調(diào)度
    gopark(chanparkcommit, unsafe.Pointer(&c.lock), waitReasonChanSend, traceEvGoBlockSend, 2)
    // 被喚醒之后執(zhí)行清理工作并釋放sudog結(jié)構(gòu)體
    gp.waiting = nil
    gp.activeStackChans = false
    closed := !mysg.success // gp被喚醒的原因是因?yàn)閿?shù)據(jù)傳遞還是通道被關(guān)閉
    gp.param = nil
    mysg.c = nil
    releaseSudog(mysg)
    // 因關(guān)閉被喚醒則panic
    if closed {
        panic(plainError("send on closed channel"))
    }
    // 數(shù)據(jù)成功傳遞
    return true
}

func chansend(c *hchan, ep unsafe.Pointer, block bool, callerpc uintptr) bool {
    // 1.channel為nil
    if c == nil {
        // 當(dāng)前Goroutine阻塞掛起
        gopark(nil, nil, waitReasonChanSendNilChan, traceEvGoStop, 2)
        throw("unreachable")
    }
    // 2.加鎖
    lock(&c.lock) 
    // 3.如果channel已關(guān)閉，直接panic
    if c.closed != 0 {
        unlock(&c.lock)
        panic(plainError("send on closed channel"))
    }
    // 4、存在阻塞讀協(xié)程
    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) // 直接把正在發(fā)送的值發(fā)送給等待接收的Goroutine，并將此接收協(xié)程放入可調(diào)度隊(duì)列等待調(diào)度
        return true
    }
    // 5、緩沖區(qū)未滿時(shí)
    if c.qcount < c.dataqsiz {
        // Space is available in the channel buffer. Enqueue the element to send.
        qp := chanbuf(c, c.sendx) // 獲取指向緩沖區(qū)數(shù)組中位于sendx位置的元素的指針
        typedmemmove(c.elemtype, qp, ep) // 將當(dāng)前發(fā)送的值拷貝到緩沖區(qū)
        c.sendx++ 
        if c.sendx == c.dataqsiz {
            c.sendx = 0 // 因?yàn)槭茄h(huán)隊(duì)列，sendx等于隊(duì)列長度時(shí)置為0
        }
        c.qcount++
        unlock(&c.lock)
        return true
    }
    // Block on the channel. 
    // 6、將當(dāng)前協(xié)程打包成一個(gè)sudog結(jié)構(gòu)體，并加入到channel的阻塞寫隊(duì)列sendq
    gp := getg()
    mysg := acquireSudog()
    mysg.elem = ep
    mysg.waitlink = nil
    mysg.g = gp
    mysg.c = c
    gp.waiting = mysg
    gp.param = nil
    c.sendq.enqueue(mysg) // 入sendq等待隊(duì)列
    atomic.Store8(&gp.parkingOnChan, 1)
    // 7.調(diào)用gopark將當(dāng)前協(xié)程設(shè)置為等待狀態(tài)并解鎖，進(jìn)入休眠，等待被喚醒，并觸發(fā)協(xié)程調(diào)度
    gopark(chanparkcommit, unsafe.Pointer(&c.lock), waitReasonChanSend, traceEvGoBlockSend, 2)
    // 8. 被喚醒之后執(zhí)行清理工作并釋放sudog結(jié)構(gòu)體
    gp.waiting = nil
    gp.activeStackChans = false
    closed := !mysg.success // g被喚醒的原因是因?yàn)閿?shù)據(jù)傳遞還是通道被關(guān)閉
    gp.param = nil
    mysg.c = nil
    releaseSudog(mysg)
    // 9.因關(guān)閉被喚醒則panic
    if closed {
        panic(plainError("send on closed channel"))
    }
    // 10.數(shù)據(jù)成功傳遞
    return true
}

func chanrecv(c *hchan, ep unsafe.Pointer, block bool) (selected, received bool) {
    // 1.channel為nil
    if c == nil {
        // 否則，當(dāng)前Goroutine阻塞掛起
        gopark(nil, nil, waitReasonChanReceiveNilChan, traceEvGoStop, 2)
        throw("unreachable")
    }
    lock(&c.lock)
    // 2.如果channel已關(guān)閉，并且緩沖區(qū)無元素，返回(true,false)
    if c.closed != 0 {
        if c.qcount == 0 {
            unlock(&c.lock)
            if ep != nil {
                //根據(jù)channel元素的類型清理ep對(duì)應(yīng)地址的內(nèi)存，即ep接收了channel元素類型的零值
                typedmemclr(c.elemtype, ep)
            }
            return true, false
        }
    }
}

func chanrecv(c *hchan, ep unsafe.Pointer, block bool) (selected, received bool) {
    lock(&c.lock)
    // Just found waiting sender with not closed.
    // 等待發(fā)送的隊(duì)列sendq里存在Goroutine
    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).
        // 如果無緩沖區(qū)，那么直接從sender接收數(shù)據(jù)；否則，從buf隊(duì)列的頭部接收數(shù)據(jù)，并把sender的數(shù)據(jù)加到buf隊(duì)列的尾部
        recv(c, sg, ep, func() { unlock(&c.lock) }, 3)
        return true, true // 接收成功
    }
}
// recv processes a receive operation on a full channel c.
func recv(c *hchan, sg *sudog, ep unsafe.Pointer, unlockf func(), skip int) {
    // channel無緩沖區(qū)，直接從sender讀
    if c.dataqsiz == 0 {
        if ep != nil {
            // copy data from sender
            t := c.elemtype
            src := sg.elem
            typeBitsBulkBarrier(t, uintptr(ep), uintptr(src), t.size)
            memmove(dst, src, t.size)
        }
    } else {
        // 從隊(duì)列讀,sender再寫入隊(duì)列
        qp := chanbuf(c, c.recvx)
        // copy data from queue to receiver
        if ep != nil {
            typedmemmove(c.elemtype, ep, qp)
        }
        // copy data from sender to queue
        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
    }
    // 喚醒sender隊(duì)列協(xié)程sg
    sg.elem = nil
    gp := sg.g
    unlockf()
    gp.param = unsafe.Pointer(sg)
    sg.success = true
    // 喚醒協(xié)程
    goready(gp, skip+1)
}

func chanrecv(c *hchan, ep unsafe.Pointer, block bool) (selected, received bool) {
    lock(&c.lock)
    // 緩沖區(qū)buf中有元素,直接從buf拷貝元素到當(dāng)前協(xié)程(在已關(guān)閉的情況下，隊(duì)列有數(shù)據(jù)依然會(huì)讀)
    if c.qcount > 0 {
        // Receive directly from queue
        qp := chanbuf(c, c.recvx)
        if ep != nil {
            typedmemmove(c.elemtype, ep, qp)// 將從buf中取出的元素拷貝到當(dāng)前協(xié)程
        }
        typedmemclr(c.elemtype, qp) // 同時(shí)將取出的數(shù)據(jù)所在的內(nèi)存清空
        c.recvx++
        if c.recvx == c.dataqsiz {
            c.recvx = 0
        }
        c.qcount--
        unlock(&c.lock)
        return true, true // 接收成功
    }
}

func chanrecv(c *hchan, ep unsafe.Pointer, block bool) (selected, received bool) {
    lock(&c.lock)
    // no sender available: block on this channel.
    // 阻塞模式，獲取當(dāng)前Goroutine，打包一個(gè)sudog，并加入到channel的接收隊(duì)列recvq里
    gp := getg()
    mysg := acquireSudog()
    mysg.elem = ep
    gp.waiting = mysg
    mysg.g = gp
    mysg.c = c
    gp.param = nil
    c.recvq.enqueue(mysg) // 入接收隊(duì)列recvq
    // 掛起當(dāng)前Goroutine，設(shè)置為_Gwaiting狀態(tài)，進(jìn)入休眠等待被喚醒
    gopark(chanparkcommit, unsafe.Pointer(&c.lock), waitReasonChanReceive, traceEvGoBlockRecv, 2)
    // 因通道關(guān)閉或者讀到數(shù)據(jù)被喚醒
    gp.waiting = nil
    success := mysg.success
    gp.param = nil
    mysg.c = nil
    releaseSudog(mysg)
    return true, success // 10.返回成功
}

// chanrecv receives on channel c and writes the received data to ep.
// ep may be nil, in which case received data is ignored.
// If block == false and no elements are available, returns (false, false).
// Otherwise, if c is closed, zeros *ep and returns (true, false).
// Otherwise, fills in *ep with an element and returns (true, true).
// A non-nil ep must point to the heap or the caller's stack.
func chanrecv(c *hchan, ep unsafe.Pointer, block bool) (selected, received bool) {
    // 1.channel為nil
    if c == nil {
        // 否則，當(dāng)前Goroutine阻塞掛起
        gopark(nil, nil, waitReasonChanReceiveNilChan, traceEvGoStop, 2)
        throw("unreachable")
    }
    // 2.加鎖
    lock(&c.lock)
    // 3.如果channel已關(guān)閉，并且緩沖區(qū)無元素，返回(true,false)
    if c.closed != 0 {
        if c.qcount == 0 {
            unlock(&c.lock)
            if ep != nil {
                //根據(jù)channel元素的類型清理ep對(duì)應(yīng)地址的內(nèi)存，即ep接收了channel元素類型的零值
                typedmemclr(c.elemtype, ep)
            }
            return true, false
        }
        // The channel has been closed, but the channel's buffer have data.
    } else {
        // Just found waiting sender with not closed.
        // 4.存在阻塞寫協(xié)程
        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).
            // 如果無緩沖區(qū)，那么直接從sender接收數(shù)據(jù)；否則，從buf隊(duì)列的頭部接收數(shù)據(jù)，并把sender的數(shù)據(jù)加到buf隊(duì)列的尾部
            recv(c, sg, ep, func() { unlock(&c.lock) }, 3)
            return true, true // 接收成功
        }
    }
    // 5.緩沖區(qū)buf中有元素,直接從buf拷貝元素到當(dāng)前協(xié)程(在已關(guān)閉的情況下，隊(duì)列有數(shù)據(jù)依然會(huì)讀)
    if c.qcount > 0 {
        // Receive directly from queue
        qp := chanbuf(c, c.recvx)
        if ep != nil {
            typedmemmove(c.elemtype, ep, qp)// 將從buf中取出的元素拷貝到當(dāng)前協(xié)程
        }
        typedmemclr(c.elemtype, qp) // 同時(shí)將取出的數(shù)據(jù)所在的內(nèi)存清空
        c.recvx++
        if c.recvx == c.dataqsiz {
            c.recvx = 0
        }
        c.qcount--
        unlock(&c.lock)
        return true, true // 接收成功
    }
    // no sender available: block on this channel.
    // 6.獲取當(dāng)前Goroutine，封裝成sudog節(jié)點(diǎn)，加入channel阻塞讀隊(duì)列recvq
    gp := getg()
    mysg := acquireSudog()
    mysg.elem = ep
    mysg.waitlink = nil
    gp.waiting = mysg
    mysg.g = gp
    mysg.c = c
    gp.param = nil
    c.recvq.enqueue(mysg) // 入接收隊(duì)列recvq
    atomic.Store8(&gp.parkingOnChan, 1)
    // 7.掛起當(dāng)前Goroutine，設(shè)置為_Gwaiting狀態(tài)，進(jìn)入休眠等待被喚醒
    gopark(chanparkcommit, unsafe.Pointer(&c.lock), waitReasonChanReceive, traceEvGoBlockRecv, 2)
    // 8.因通道關(guān)閉或者可讀被喚醒
    gp.waiting = nil
    gp.activeStackChans = false
    success := mysg.success
    gp.param = nil
    mysg.c = nil
    releaseSudog(mysg)
    // 9.返回
    return true, success 
}

func closechan(c *hchan) {
    // // 1.channel為nil則panic
    if c == nil {
        panic(plainError("close of nil channel"))
    }
    lock(&c.lock)
    // 2.已關(guān)閉的channel再次關(guān)閉則panic
    if c.closed != 0 {
        unlock(&c.lock)
        panic(plainError("close of closed channel"))
    }
    // 設(shè)置關(guān)閉標(biāo)記
    c.closed = 1
    var glist gList
    // 遍歷recvq和sendq中的協(xié)程放入glist
    // release all readers
    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 = unsafe.Pointer(sg)
        sg.success = false
        glist.push(gp)
    }
    // release all writers (they will panic)
    for {
        sg := c.sendq.dequeue()
        if sg == nil {
            break
        }
        sg.elem = nil
        if sg.releasetime != 0 {
            sg.releasetime = cputicks()
        }
        gp := sg.g
        gp.param = unsafe.Pointer(sg)
        sg.success = false
        glist.push(gp)
    }
    unlock(&c.lock)
    // 3.將glist中所有Goroutine的狀態(tài)置為_Grunnable，等待調(diào)度器進(jìn)行調(diào)度
    for !glist.empty() {
        gp := glist.pop()
        gp.schedlink = 0
        goready(gp, 3)
    }
}