package main

func main() {
	_ = make(chan int)
}

go tool compile -N -l -S main.go

// 其內部維護了一個循環(huán)隊列(數組), 用于管理發(fā)送與接收的緩存數據. 
type hchan struct {
  // 隊列中元素個數
	qcount   uint
  // 隊列的大小(數組長度)
	dataqsiz uint
  // 指向底層的緩存隊列, 是一個可以指向任意類型的指針. 
	buf      unsafe.Pointer
  // 管道每個元素的大小
	elemsize uint16
  // 是否被關閉了
	closed   uint32
  // 管道的元素類型
	elemtype *_type
  // 當前可以發(fā)送的元素索引(隊尾)
	sendx    uint  
  // 當前可以接收的元素索引(隊首)
	recvx    uint  
  // 當前等待接收數據的 goroutine 隊列
	recvq    waitq
  // 當前等待發(fā)送數據的 goroutine 隊列
	sendq    waitq 
	// 鎖, 用來保證管道的每個操作都是原子性的. 
	lock mutex
}

func chansend(c *hchan, ep unsafe.Pointer, block bool, callerpc uintptr) bool {
  // 異常處理, 若管道指針為空
	if c == nil {
		if !block {
			return false
		}
		gopark(nil, nil, waitReasonChanSendNilChan, traceEvGoStop, 2)
		throw("unreachable")
	}
	// 常量判斷, 恒為 false, 應該是開發(fā)時調試用的. 
	if debugChan {
		print("chansend: chan=", c, "\n")
	}
	// 常量, 恒為 false, 沒看懂這個判斷
	if raceenabled {
		racereadpc(c.raceaddr(), callerpc, funcPC(chansend))
	}
  // 若當前操作不阻塞, 且管道還沒有關閉時判斷
  // 當前隊列容量為0且沒有等待接收數據的 或 當前隊列容量不為0且隊列已滿
  // 那么問題來了, 什么時候不加鎖呢? select 的時候. 可以在不阻塞的時候快速返回
	if !block && c.closed == 0 && ((c.dataqsiz == 0 && c.recvq.first == nil) ||
		(c.dataqsiz > 0 && c.qcount == c.dataqsiz)) {
		return false
	}
	// 上鎖, 保證操作的原子性
	lock(&c.lock)
	// 若管道已經關閉, 報錯
	if c.closed != 0 {
		unlock(&c.lock)
		panic(plainError("send on closed channel"))
	}
	// 從接受者隊列獲取一個接受者, 若存在, 數據直接發(fā)送, 不走緩存, 提高效率
	if sg := c.recvq.dequeue(); sg != nil {
		send(c, sg, ep, func() { unlock(&c.lock) }, 3)
		return true
	}
	// 若緩存為滿, 則將數據放到緩存中排隊
	if c.qcount < c.dataqsiz {
    // 取出對尾的地址
		qp := chanbuf(c, c.sendx)
    // 將ep 的內容拷貝到 ap 地址
		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
	}
	// 當走到這里, 說明數據沒有成功發(fā)送, 且需要阻塞等待. 
  // 以下代碼沒看懂, 不過可以肯定的是, 其操作為阻塞當前協(xié)程, 等待發(fā)送數據
	gp := getg()
	mysg := acquireSudog()
	mysg.releasetime = 0
	if t0 != 0 {
		mysg.releasetime = -1
	}
	mysg.elem = ep
	mysg.waitlink = nil
	mysg.g = gp
	mysg.isSelect = false
	mysg.c = c
	gp.waiting = mysg
	gp.param = nil
	c.sendq.enqueue(mysg)
	gopark(chanparkcommit, unsafe.Pointer(&c.lock), waitReasonChanSend, traceEvGoBlockSend, 2)
	KeepAlive(ep)
	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
}

// compiler implements
//
//	select {
//	case c <- v:
//		... foo
//	default:
//		... bar
//	}
//
// as
//
//	if selectnbsend(c, v) {
//		... foo
//	} else {
//		... bar
//	}
//
func selectnbsend(c *hchan, elem unsafe.Pointer) (selected bool) {
	return chansend(c, elem, false, getcallerpc())
}

// 創(chuàng)建普通的管道類型, 非緩沖
a := make(chan int)
// 創(chuàng)建緩沖區(qū)大小為10的管道
b := make(chan int, 10)
// 創(chuàng)建只用來發(fā)送的管道
c := make(chan<- int)
// 創(chuàng)建只用來接收的管道
d := make(<-chan int)
// eg: 只用來接收的管道, 每秒一個
e := time.After(time.Second)

// 接收數據
a := <- ch
b, ok := <- ch
// 發(fā)送數據
ch <- 2