type hchan struct {
	qcount   uint           // buf當前元素的數量
	dataqsiz uint           // buf的容量
	buf      unsafe.Pointer // channel緩沖區，一個循環數組
	elemsize uint16         // 元素大小
	closed   uint32         // channel關閉標記
	elemtype *_type         // element type
	sendx    uint           // 當下一次發送數據到channel時，數據存放到buf中的哪個index
	recvx    uint           // 當下一次從channel接收數據時，從buf的哪個index獲取數據
	recvq    waitq          // 等待接收數據的goroutine列表，雙向鏈表
	sendq    waitq          // 等待發送數據的goroutine列表，雙向鏈表
	lock     mutex          // 互斥鎖，發送和接收操作前需要獲取的鎖，所以channel的發送和接收操作是互斥的
}

type waitq struct {
	first *sudog
	last  *sudog
}

// sudog表示等待隊列中的一個g，例如在一個channel中的發送/接收。
// sudog是必要的，因為g和同步對象的關系是多對多的，一個g可以在多個等待隊列中，因此一個g會有很多個sudog，
// 很多g可能在等待著同一個同步對象，因此一個對象可能有多個sudog。
// sudog是從一個特殊的池中分配的，使用acquireSudog和releaseSudog分配和釋放它們。
type sudog struct {
	// 以下字段受此sudog阻塞的channel的hchan.lock保護
	g *g
	next *sudog
	prev *sudog
	elem unsafe.Pointer // data element (may point to stack)
	// 以下字段永遠不會被同時訪問
	// 對于channel，waitlink只能被g訪問
	// 對于信號量，所有字段（包括上述字段）只有在持有semaRoot鎖時才能訪問。
	acquiretime int64
	releasetime int64
	ticket      uint32
	// isSelect表示g正在參與選擇，因此g.selectDone必須經過CAS處理，才能被喚醒
	isSelect bool
	// success表示通過channel c的通信是否成功。
	// 如果goroutine因為通過channel c傳遞了一個值而被喚醒，則為true
	// 如果因為c被關閉而喚醒，則為false
	success bool
	parent   *sudog // semaRoot binary tree
	waitlink *sudog // g.waiting list or semaRoot
	waittail *sudog // semaRoot
	c        *hchan // channel
}

// 無緩沖channel
ch := make(chan int)
// 緩沖大小為5的channel
ch2 := make(chan int, 5)

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")
	}
	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:
		// 隊列或元素大小為0，即無緩沖channel
		c = (*hchan)(mallocgc(hchanSize, nil, true))
		// Race detector uses this location for synchronization.
		c.buf = c.raceaddr()
	case elem.ptrdata == 0:
		// 元素不包含指針類型，只進行一次 hchan 和 buf 的內存分配
		// 當存儲在buf中的元素不包含指針時，GC就不會掃描hchan中的元素
		c = (*hchan)(mallocgc(hchanSize+mem, nil, true))
		c.buf = add(unsafe.Pointer(c), hchanSize)
	default:
		// 元素中包含指針類型，進行2次內存分配操作
		// 用new分配內存返回的是指針
		c = new(hchan)
		c.buf = mallocgc(mem, elem, true)
	}
	// 初始化channel數據
	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")
	}
	// 返回 hchan 的指針類型
	return c
}

func chansend(c *hchan, ep unsafe.Pointer, block bool, callerpc uintptr) bool {
	// 如果當前channel是nil
	if c == nil {
		// 如果不阻塞，則直接返回false
		if !block {
			return false
		}
		// 掛起當前goroutine
		gopark(nil, nil, waitReasonChanSendNilChan, traceEvGoStop, 2)
		throw("unreachable")
	}
	if debugChan {
		print("chansend: chan=", c, "\n")
	}
	if raceenabled {
		racereadpc(c.raceaddr(), callerpc, funcPC(chansend))
	}
	// 這里訪問了hchan結構中的closed, full函數內部訪問了dataqsiz,recvq,qcount字段，這里沒有加鎖，是為什么呢？
	// 先說說這里判斷的含義：如果不阻塞，且channel沒有被關閉，且buf已滿，則快速返回false，表示數據發送失敗。
	// 因為沒有加鎖，假如在判斷c.closed == 0之后結果為true，在判斷full之前，這時channel被其他goroutine關閉了，
	// 然后full函數返回了true，那么它會直接return false，這樣子會有什么影響呢？
	// 其實并沒有什么影響，在這種情況下返回false也是合理的，因為都是表示在不阻塞的情況下發送數據失敗。
	// 所以這里訪問hchan里面的數據就沒有加鎖了
	if !block && c.closed == 0 && full(c) {
		return false
	}
	var t0 int64
	if blockprofilerate > 0 {
		t0 = cputicks()
	}
	// 鎖住channel，可見channel是并發安全的
	lock(&c.lock)
	// 如果channel已關閉，則panic
	if c.closed != 0 {
		unlock(&c.lock)
		panic(plainError("send on closed channel"))
	}
	// 如果recvq等待接收隊列中有值，則直接把值傳給等待接收的goroutine，這樣可以減少一次內存拷貝
	if sg := c.recvq.dequeue(); sg != nil {
		send(c, sg, ep, func() { unlock(&c.lock) }, 3)
		return true
	}
	// 如果recvq等待接收隊列中沒有值，且為有緩沖channel，則把數據copy到buf中
	if c.qcount < c.dataqsiz {
		// Space is available in the channel buffer. Enqueue the element to send.
		qp := chanbuf(c, c.sendx)
		if raceenabled {
			racenotify(c, c.sendx, nil)
		}
		typedmemmove(c.elemtype, qp, ep)
		c.sendx++
		// 因為buf是環形數組，所以如果sendx超出了最大index，就要歸0
		if c.sendx == c.dataqsiz {
			c.sendx = 0
		}
		c.qcount++
		unlock(&c.lock)
		return true
	}
	// 如果recvq等待接收隊列中沒有值，且為無緩沖channel，且不阻塞，則直接返回false
	if !block {
		unlock(&c.lock)
		return false
	}
	// 接下來做阻塞當前goroutine的一些準備工作，構造一個sudog
	// 獲取當前goroutine的指針
	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
	mysg.g = gp
	mysg.isSelect = false
	mysg.c = c
	gp.waiting = mysg
	gp.param = nil
	// 把構建好的 sudog 加到 sendq 發送等待隊列中
	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)
	// 掛起當前goroutine
	gopark(chanparkcommit, unsafe.Pointer(&c.lock), waitReasonChanSend, traceEvGoBlockSend, 2)
	// 如果當前 goroutine 被喚醒后，會在這里繼續執行
	// 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
	closed := !mysg.success
	gp.param = nil
	if mysg.releasetime > 0 {
		blockevent(mysg.releasetime-t0, 2)
	}
	mysg.c = nil
	releaseSudog(mysg)
	if closed {
		if c.closed == 0 {
			throw("chansend: spurious wakeup")
		}
		// 如果喚醒后，發現 channel 被關閉，則關閉
		panic(plainError("send on closed channel"))
	}
	return true
}

// 判斷channel中是否還有位置存放數據
func full(c *hchan) bool {
	// 如果是非緩沖channel
	if c.dataqsiz == 0 {
		// 如果 recvq 中沒有等待接收數據的 goroutine，則返回 true，表示已滿，否則返回 false
		return c.recvq.first == nil
	}
	// 如果是有緩沖 channel，則判斷buf是否已滿
	return c.qcount == c.dataqsiz
}

// 在一個空的 channel c 中完成發送操作
// 把數據 ep 從發送者復制到接收者 sg 中
// 最后接收的 goroutine 會被喚醒
// channel c 一定是空的且被鎖住的
// sg 一定是已經從 c 的 recvq 中出隊了
// eq 一定是不等于 nil 的，且指向堆或者是調用者的棧
func send(c *hchan, sg *sudog, ep unsafe.Pointer, unlockf func(), skip int) {
	if raceenabled {
		if c.dataqsiz == 0 {
			racesync(c, sg)
		} else {
			// Pretend we go through the buffer, even though
			// we copy directly. Note that we need to increment
			// the head/tail locations only when raceenabled.
			racenotify(c, c.recvx, nil)
			racenotify(c, c.recvx, sg)
			c.recvx++
			if c.recvx == c.dataqsiz {
				c.recvx = 0
			}
			c.sendx = c.recvx // c.sendx = (c.sendx+1) % c.dataqsiz
		}
	}
	// sg.elem 指向接收者存放接收數據的存放的位置
	if sg.elem != nil {
		// 直接內存拷貝，從發送者拷貝到接收者內存
		sendDirect(c.elemtype, sg, ep)
		sg.elem = nil
	}
	gp := sg.g
	// 解鎖
	unlockf()
	gp.param = unsafe.Pointer(sg)
	sg.success = true
	if sg.releasetime != 0 {
		sg.releasetime = cputicks()
	}
	// 喚醒接收數據的goroutine
	goready(gp, skip+1)
}

// 無返回值
func chanrecv1(c *hchan, elem unsafe.Pointer) {
	chanrecv(c, elem, true)
}
// 返回 bool 類型，如果返回false,表示 channel 已經被關閉，否則返回false。 
func chanrecv2(c *hchan, elem unsafe.Pointer) (received bool) {
	_, received = chanrecv(c, elem, true)
	return
}

// 從 channel c 中接收數據，并把數據復制到 ep 中。
// 在忽略接收數據的情況下，eq 可能是 nil，例如：<- ch
// 如果不阻塞，且 channel 中沒有元素的情況下，直接快速返回(false, false)
// 如果 c 已經被關閉，*ep 為零值，怎返回(true, false)
// 如果 *ep 中有元素，則返回(true, true)
// 一個不等于 nil 的 eq 一定指向堆或者調用者的棧
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
		}
		// 如果 c 為 nil，掛起當前 goroutine
		gopark(nil, nil, waitReasonChanReceiveNilChan, traceEvGoStop, 2)
		throw("unreachable")
	}
	// Fast path: check for failed non-blocking operation without acquiring the lock.
	// 在非阻塞模式下，快速檢測接收失敗的情況
	if !block && empty(c) {
		// 發現 channel 沒有準備好要接收數據后，我們觀察通道是否已經關閉。
		// 重新排序這些檢查可能會導致在關閉時不正確的行為。
		// 例如，如果通道是open，且not empty，然后被關閉，接著排空->empty，
		// 重新排序的讀取可能會錯誤地表示成”open和empty“。
		// 為了防止重排序，我們對這2個檢查都使用原子加載，并依靠清空和關閉發生在同一個鎖下的不同臨界區。
		// 當關閉帶有阻塞發送的非緩沖channel，此假設失敗，但這無論如何都是錯誤的條件。
		if atomic.Load(&c.closed) == 0 {
			// 因為 channel 不能重新打開，所以在后面這里觀察到 channel 沒有被關閉，意味著它在第一次判斷 empty 的時候也沒有關閉。
			// 這樣就表現得像在第一次判斷 empty 時，通道也沒有關閉：if empty(c) && atomic.Load(&c.closed) == 0 {...}
			return
		}
		// 當執行到這里的時候，說明 channel 已經被關閉了。
		// 這時重新檢查通道是否還有其他待接收的數據，這些數據可能在第一次 empty 檢查和通道關閉檢查之間到達。
		// 在這種情況下發送時，也需要按照連貫的順序。
		if empty(c) {
			// The channel is irreversibly closed and empty.
			if raceenabled {
				raceacquire(c.raceaddr())
			}
			if ep != nil {
				typedmemclr(c.elemtype, ep)
			}
			return true, false
		}
	}
	var t0 int64
	if blockprofilerate > 0 {
		t0 = cputicks()
	}
	// 獲取鎖
	lock(&c.lock)
	// 如果 channel c 已經被關閉，且 buf 中無元素，將獲取到零值
	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 中有元素
	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).
		// 找到一個正在等待的發送者。
		// 1.如果是無緩沖 channel，則直接把從發送者那里接收數據。
		// 2.如果是有緩沖 channel，這時 sendq 中有元素，說明 buf 滿了，發送者需要等待消費者消費 buf 數據后才能繼續發送數據。
		// 	 這時當前的 goroutine 會從 buf 的 recvx 位置接收數據，并且把剛剛獲取到的發送者 sg 的發送數據拷貝到 buf 的 sendx 位置中。
		recv(c, sg, ep, func() { unlock(&c.lock) }, 3)
		return true, true
	}
	// sendq 中沒有等待的發送者，且 buf 中有數據，則直接從 buf 中接收數據
	if c.qcount > 0 {
		// Receive directly from queue
		qp := chanbuf(c, c.recvx)
		if raceenabled {
			racenotify(c, c.recvx, nil)
		}
		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
	}
	// 如果代碼運行到這里，說明 channel 中沒有數據可以接收了，接下來就要準備阻塞當前 goroutine 了
	// 如果不阻塞，則快速返回
	if !block {
		// 解鎖
		unlock(&c.lock)
		return false, false
	}
	// no sender available: block on this channel.
	// 構造sudog
	// 獲取當前 goroutine 指針
	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
	// 把構造好的 sudog 入隊 recvq
	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
	gopark(chanparkcommit, unsafe.Pointer(&c.lock), waitReasonChanReceive, traceEvGoBlockRecv, 2)
	// 如果 goroutine 被喚醒，會從這里開始繼續執行
	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)
	}
	success := mysg.success
	gp.param = nil
	mysg.c = nil
	releaseSudog(mysg)
	return true, success
}

func empty(c *hchan) bool {
	// c.dataqsiz 是不會被改變的.
	if c.dataqsiz == 0 {
		return atomic.Loadp(unsafe.Pointer(&c.sendq.first)) == nil
	}
	return atomic.Loaduint(&c.qcount) == 0
}

// 這里分為 2 個部分：
// 1.發送者 sg 待發送的值會被放入通道 buf 中，發送者被喚醒繼續執行
// 2.接收方（當前 goroutine）接收的值寫入 ep
// 對于同步 channel（無緩沖），2 個值都是一樣的
// 對于異步 channel（有緩沖），接收方從 channel buf 獲取數據，發送方的數據放入 channel buf
// channel c 一定是滿的，且已被鎖定，recv 用 unlockf 解鎖 channel c。
// sg 一定已經從 sendq 出隊
// 不等于 nil 的 ep 一定指向堆或調用者的棧
func recv(c *hchan, sg *sudog, ep unsafe.Pointer, unlockf func(), skip int) {
	if c.dataqsiz == 0 {
		if raceenabled {
			racesync(c, sg)
		}
		if ep != nil {
			// 非緩沖 channel，直接從發送方接收數據
			recvDirect(c.elemtype, sg, ep)
		}
	} else {
		// 緩沖 channel，buf 已滿
		// 先從 buf 隊列頭部接收數據，然后把獲取出來的發送方數據入隊
		qp := chanbuf(c, c.recvx)
		if raceenabled {
			racenotify(c, c.recvx, nil)
			racenotify(c, c.recvx, sg)
		}
		// 從 buf 中復制數據到接收方
		if ep != nil {
			typedmemmove(c.elemtype, ep, qp)
		}
		// 把發送方 sg 的數據復制到 buf 中
		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)
	sg.success = true
	if sg.releasetime != 0 {
		sg.releasetime = cputicks()
	}
	// 喚醒發送方 goroutine
	goready(gp, skip+1)
}