Golang Channel 底层：hchan、环形队列与等待队列的精密协作

type hchan struct {
	qcount   uint           // 当前队列中的元素个数
	dataqsiz uint           // 环形队列大小（缓冲 channel 的容量）
	buf      unsafe.Pointer // 环形队列指针
	elemsize uint16         // 每个元素大小
	closed   uint32         // 是否已关闭
	elemtype *_type         // 元素类型元数据
	sendx    uint           // 发送索引
	recvx    uint           // 接收索引
	recvq    waitq          // 等待接收的 goroutine 队列
	sendq    waitq          // 等待发送的 goroutine 队列
	lock     mutex          // 保护 hchan 的锁
}

初始：sendx=0, recvx=0, qcount=0
send 1：buf[0]=1, sendx=1, qcount=1
send 2：buf[1]=2, sendx=2, qcount=2
recv 1：v=buf[0], recvx=1, qcount=1
send 3：buf[2]=3, sendx=3(模回0), qcount=2

package main
import (
	"fmt"
	"time"
)
func main() {
	ch := make(chan int, 3)
	// 发送 3 个，不阻塞
	for i := 1; i <= 3; i++ {
		ch <- i
		fmt.Printf("sent %d\n", i)
	}
	// 第 4 个发送会阻塞，除非有 goroutine 接收
	go func() {
		time.Sleep(100 * time.Millisecond)
		fmt.Println("receiver waking up")
		v := <-ch
		fmt.Printf("received %d\n", v)
	}()
	fmt.Println("about to block on 4th send")
	ch <- 4
	fmt.Println("4th send succeeded after receiver took one")
	// 清空剩余
	for v := range ch {
		fmt.Printf("drain %d\n", v)
		if len(ch) == 0 {
			break
		}
	}
}

package main
import (
	"fmt"
	"sync"
	"time"
)
func main() {
	ch := make(chan int)
	var wg sync.WaitGroup
	wg.Add(2)
	go func() {
		defer wg.Done()
		fmt.Println("sender: preparing data at", time.Now().Format("15:04:05.000"))
		ch <- 42 // 会阻塞，直到接收方准备好
		fmt.Println("sender: handoff complete at", time.Now().Format("15:04:05.000"))
	}()
	go func() {
		defer wg.Done()
		time.Sleep(200 * time.Millisecond)
		fmt.Println("receiver: ready at", time.Now().Format("15:04:05.000"))
		v := <-ch
		fmt.Println("receiver: got", v)
	}()
	wg.Wait()
}

package main
import "fmt"
func main() {
	ch := make(chan int, 3)
	ch <- 1
	ch <- 2
	close(ch)
	for v := range ch {
		fmt.Println("range got", v)
	}
	v, ok := <-ch
	fmt.Printf("after close: v=%d ok=%v\n", v, ok)
}