1）chan结构体-hchan

• channel内部是固定长度的双向循环链表，make时确认size大小
• 环形队列有关的变量：
  qcount 入队元素数
  dataqsiz 队列容量
  sendx发送索引
  recvx接收索引
• 关于发送缓冲队列和接收缓冲队列：
  当写阻塞队列不空，说明chan的buf已经无法写了，并且读阻塞队列为空
  当读阻塞队列不空，说明chan的buf和sendq均为空

type hchan struct {
  
  qcount   uint           // 当前队列中总元素个数
  dataqsiz uint           // 环形队列长度，即缓冲区大小（申明channel时指定的大小）
  
  buf      unsafe.Pointer // 环形队列指针
  
  elemsize uint16         // buf中每个元素的大小
 
  closed   uint32        // 0为正常，关闭时字段为1
  
  elemtype *_type // 元素类型，用于传值过程的赋值
  // 环形缓冲区中已发送位置索引
  sendx    uint   // send index
  // 环形缓冲区中已接收位置索引
  recvx    uint   // receive index
  // 等待读消息的groutine队列。
  // 当读阻塞队列不空，说明chan的buf和sendq均为空
  recvq    waitq  // list of recv waiters,放的是等待接收的睡眠协程
  // 等待写消息的groutine队列
  // 当写阻塞队列不空，说明chan的buf已经无法写了，并且读阻塞队列为空
  sendq    waitq  // list of send waiters，放的是等待发送的睡眠协程
  // 互斥锁，为每个读写操作锁定通道（发送和接收必须互斥）
  lock mutex
}
// 等待读写的队列数据结构，保证先进先出
type waitq struct {
  first *sudog
  last  *sudog
}

2）make chan

hchanSize = unsafe.Sizeof(hchan{}) + uintptr(-int(unsafe.Sizeof(hchan{}))&(maxAlign-1))
//hchanSize返回实际占用的内存大小，扣去字节对齐部分
// 对应的源码为 c := make(chan int, size)
// c := make(chan int) 这种情况下，size = 0

func makechan(t *chantype, size int) *hchan {
    elem := t.elem

    // compiler checks this but be safe.
    if elem.size >= 1<<16 {
        throw("makechan: invalid channel element type")
    }
    if hchanSize%maxAlign != 0 || elem.align > maxAlign {
        throw("makechan: bad alignment")
    }
    //判断a*b是否会溢出（对于64位机器，大于2的64次方）
    mem, overflow := math.MulUintptr(elem.size, uintptr(size))
    if overflow || mem > maxAlloc-hchanSize || size < 0 {
        panic(plainError("makechan: size out of range"))
    }

    // Hchan does not contain pointers interesting for GC when elements stored in buf do not contain pointers.
    // buf points into the same allocation, elemtype is persistent.
    // SudoG's are referenced from their owning thread so they can't be collected.
    // TODO(dvyukov,rlh): Rethink when collector can move allocated objects.
    var c *hchan
    switch {
    case mem == 0:
        // 空队列或队列中元素为空
        c = (*hchan)(mallocgc(hchanSize, nil, true))
        // Race detector uses this location for synchronization.
        // raceaddr内部实现为：return unsafe.Pointer(&c.buf)
        //c.buf存c.buf自己的地址，用于竞争探测。
        c.buf = c.raceaddr()
    case elem.ptrdata == 0:
        // elem不包含指针，直接申请hchan+mem内存大小
        // Allocate hchan and buf in one call.
        c = (*hchan)(mallocgc(hchanSize+mem, nil, true))
        c.buf = add(unsafe.Pointer(c), hchanSize)
    default:
        // Elements contain pointers.
        //包含指针，则为buf单独开辟空间
        c = new(hchan)
        c.buf = mallocgc(mem, elem, true)
    }

    c.elemsize = uint16(elem.size)
    c.elemtype = elem
    c.dataqsiz = uint(size)
    lockInit(&c.lock, lockRankHchan)

    if debugChan {
        print("makechan: chan=", c, "; elemsize=", elem.size, "; dataqsiz=", size, "\n")
    }
    return c
}

3） 发送数据
sudog 存储
sudoG 结构体：
// sudog 代表在等待列表里的 g，比如向 channel 发送/接收内容时
// 之所以需要 sudog 是因为 g 和同步对象之间的关系是多对多的
// 一个 g 可能会在多个等待队列中，所以一个 g 可能被打包为多个 sudog
// 多个 g 也可以等待在同一个同步对象上
// 因此对于一个同步对象就会有很多 sudog 了
// sudog 是从一个特殊的池中进行分配的。用 acquireSudog 和 releaseSudog 来分配和释放 sudog

//block表示是否阻塞（正常都是阻塞的，在select中有default就是非阻塞的）

func chansend(c *hchan, ep unsafe.Pointer, block bool, callerpc uintptr) bool {
    //第一种情况，空chan
    if c == nil {
        //非阻塞立即返回
        if !block {
            return false
        }
        //协程挂起
        gopark(nil, nil, waitReasonChanSendNilChan, traceEvGoStop, 2)
        throw("unreachable")
    }

    if debugChan {
        print("chansend: chan=", c, "\n")
    }

    if raceenabled {
        racereadpc(c.raceaddr(), callerpc, funcPC(chansend))
    }

    // Fast path: check for failed non-blocking operation without acquiring the lock.
    //
    // After observing that the channel is not closed, we observe that the channel is
    // not ready for sending. Each of these observations is a single word-sized read
    // (first c.closed and second full()).
    // Because a closed channel cannot transition from 'ready for sending' to
    // 'not ready for sending', even if the channel is closed between the two observations,
    // they imply a moment between the two when the channel was both not yet closed
    // and not ready for sending. We behave as if we observed the channel at that moment,
    // and report that the send cannot proceed.
    //
    // It is okay if the reads are reordered here: if we observe that the channel is not
    // ready for sending and then observe that it is not closed, that implies that the
    // channel wasn't closed during the first observation. However, nothing here
    // guarantees forward progress. We rely on the side effects of lock release in
    // chanrecv() and closechan() to update this thread's view of c.closed and full().
    //未关闭的chan且非阻塞状态如果满了就立即返回
    if !block && c.closed == 0 && full(c) {
        return false
    }

    var t0 int64
    if blockprofilerate > 0 {
        t0 = cputicks()
    }
    //互斥锁上锁
    lock(&c.lock)
    //向已经关闭的chan发数据会panic
    if c.closed != 0 {
        unlock(&c.lock)
        panic(plainError("send on closed channel"))
    }
    //从接收者队列中拿一个goroutine，把数据发给对应的goroutine，直接返回
    //接收队列有数据，说明buf环为空
    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
    }
    
    //没有等待接收的goroutine，如果队列不空，则放入到buf中
    if c.qcount < c.dataqsiz {
        //缓存环形buf未满，直接放进去，返回
        // 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
    }
    //非阻塞，缓存满了，则放入失败
    if !block {
        unlock(&c.lock)
        return false
    }
    
    
    // Block on the channel. Some receiver will complete our operation for us.
    gp := getg()
    //获取一个sudog，把send协程信息和send内容放入到sudog
    mysg := acquireSudog()
    mysg.releasetime = 0
    if t0 != 0 {
        mysg.releasetime = -1
    }
    // No stack splits between assigning elem and enqueuing mysg
    // on gp.waiting where copystack can find it.
    mysg.elem = ep
    mysg.waitlink = nil
    mysg.g = gp
    mysg.isSelect = false
    mysg.c = c
    gp.waiting = mysg
    gp.param = nil
    //把sudong放入chan的发送阻塞队列中
    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)
    //休眠当前协程，等待某次接收流程被唤醒
    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.
    //保持ep不被gc掉
    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)//释放sudog
    return true
}
func send(c *hchan, sg *sudog, ep unsafe.Pointer, unlockf func(), skip int) {

    if sg.elem != nil {
        //直接发送的recv goroutine
        sendDirect(c.elemtype, sg, ep)
        sg.elem = nil
    }
    gp := sg.g
    //释放chan的互斥锁
    unlockf()
    gp.param = unsafe.Pointer(sg)
    if sg.releasetime != 0 {
        sg.releasetime = cputicks()
    }
    //唤醒recv 协程
    goready(gp, skip+1)
}

发送过程：
1当对一个nil chan进行写操作时，如果是非阻塞调用，直接返回；否则将当前协程挂起
2 非阻塞模式且chan未close，没有缓冲区且没有等待接收或者缓冲区满的情况下，直接return false。
3 c.recvq中有等待读的接收者（说明唤醒buf为空），将其出队，将数据直接copy给接收者，并唤醒接收者。 返回
4 缓冲区未满的情况下，数据放入环形缓冲区即可。 返回
5缓冲区满了，把go协程信息和element指针放入到新申请sudog，把sudog放入到sendq（发送阻塞队列）。
总结一下：先看接收阻塞队列，再看环形缓冲队列，最后不行就挂起当前协程放入到发送阻塞队列(对于block类型)。

4） chan读操作

1 读空chan直接阻塞当前协程
2 非阻塞状态且chan为空的话已经close直接返回0值，没close的直接返回
3 对于阻塞状态，如果已经关闭且队列为空的话，直接返回0值
开始正常步骤：
4 如果有等待发送数据的groutine，从sendq中取出一个等待发送数据的Groutine，取出数据
5 如果没有等待的groutine，且环形队列中有数据，从队列中取出数据
6 如果没有等待的groutine，且环形队列中也没有数据，则阻塞该Groutine，并将groutine打包为sudogo加入到recevq等待队列中
总结一下：先从发送阻塞队列取，没有就从缓冲区取，还没有就挂起当前协程到接收缓冲队列（block型）.

func chanrecv(c *hchan, ep unsafe.Pointer, block bool) (selected, received bool) {
   // raceenabled: don't need to check ep, as it is always on the stack
   // or is new memory allocated by reflect.

   if debugChan {
       print("chanrecv: chan=", c, "\n")
   }

   if c == nil {
       if !block {
           return
       }
       gopark(nil, nil, waitReasonChanReceiveNilChan, traceEvGoStop, 2)
       throw("unreachable")
   }

   // Fast path: check for failed non-blocking operation without acquiring the lock.
   //非阻塞时 先检查chan中是否有可以接收的数据（empty()）
   if !block && empty(c) {
       // After observing that the channel is not ready for receiving, we observe whether the
       // channel is closed.
       //
       // Reordering of these checks could lead to incorrect behavior when racing with a close.
       // For example, if the channel was open and not empty, was closed, and then drained,
       // reordered reads could incorrectly indicate "open and empty". To prevent reordering,
       // we use atomic loads for both checks, and rely on emptying and closing to happen in
       // separate critical sections under the same lock.  This assumption fails when closing
       // an unbuffered channel with a blocked send, but that is an error condition anyway.
       //chan没被关闭，直接返回
       if atomic.Load(&c.closed) == 0 {
           // Because a channel cannot be reopened, the later observation of the channel
           // being not closed implies that it was also not closed at the moment of the
           // first observation. We behave as if we observed the channel at that moment
           // and report that the receive cannot proceed.
           return
       }
       // The channel is irreversibly closed. Re-check whether the channel has any pending data
       // to receive, which could have arrived between the empty and closed checks above.
       // Sequential consistency is also required here, when racing with such a send.
       if empty(c) {
           // The channel is irreversibly closed and empty.
           if raceenabled {
               raceacquire(c.raceaddr())
           }
           if ep != nil {
               typedmemclr(c.elemtype, ep)
           }
           //已经关闭且无任何缓存数据的chan，直接返回
           return true, false
       }
   }

   var t0 int64
   if blockprofilerate > 0 {
       t0 = cputicks()
   }

   lock(&c.lock)
   //已经关闭的chan，队列没有数据，存放数据清零直接返回
   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
   }
   //如果发送队列有阻塞go协程（说明buf队列已经满了），则拿一个进行接收
   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).
       recv(c, sg, ep, func() { unlock(&c.lock) }, 3)
       return true, true
   }
   //buf队列中有数据，直接取出来一个
   if c.qcount > 0 {
       // Receive directly from queue
       qp := chanbuf(c, c.recvx)
       if raceenabled {
           raceacquire(qp)
           racerelease(qp)
       }
       if ep != nil {
           typedmemmove(c.elemtype, ep, qp)
       }
       typedmemclr(c.elemtype, qp)
       c.recvx++
       if c.recvx == c.dataqsiz {
           c.recvx = 0
       }
       c.qcount--
       unlock(&c.lock)
       return true, true
   }
   //未关闭且没数据可以取，非阻塞直接返回
   if !block {
       unlock(&c.lock)
       return false, false
   }

   // no sender available: block on this channel.
   //没任何数据可读，当前协程放入读阻塞队列
   gp := getg()
   mysg := acquireSudog()
   mysg.releasetime = 0
   if t0 != 0 {
       mysg.releasetime = -1
   }
   // No stack splits between assigning elem and enqueuing mysg
   // on gp.waiting where copystack can find it.
   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)
   gopark(chanparkcommit, unsafe.Pointer(&c.lock), waitReasonChanReceive, traceEvGoBlockRecv, 2)

   // someone woke us up
   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
   mysg.c = nil
   releaseSudog(mysg)
   return true, !closed
}

5）关闭chan操作

把读阻塞队列所有协程释放，写阻塞队列所有协程释放（并把数据丢弃）

func closechan(c *hchan) {
    //关闭空chan，直接panic
    if c == nil {
        panic(plainError("close of nil channel"))
    }

    lock(&c.lock)
    //已经关闭的chan，直接panic
    if c.closed != 0 {
        unlock(&c.lock)
        panic(plainError("close of closed channel"))
    }



    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)
    }

    // 释放写阻塞队列，同时elem都直接释放（数据丢弃，无法被读）
    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)

    // Ready all Gs now that we've dropped the channel lock.
    //释放所有被阻塞的协程
    for !glist.empty() {
        gp := glist.pop()
        gp.schedlink = 0
        goready(gp, 3)
    }
}

https://juejin.cn/post/7036279988131201054#heading-4
https://juejin.cn/post/6875325172249788429