1[线程1] ----\
2             >--[共享内存区域]--<
3[线程2] ----/        |         \
4                    |          \
5[线程3] --------------/          \
6[线程4] --------------------------/

1[Actor A]  --(消息)--> [邮箱] --> [Actor B]
2   ↑                       |
3   |_______________________|
4             (消息)

1[进程/goroutine X] --[channel]--> [进程/goroutine Y]
2      ↑                                |
3      |________________________________|
4               [channel]

 1type hchan struct {
 2	// chan 里元素数量
 3	qcount   uint
 4	// chan 底层循环数组的长度
 5	dataqsiz uint
 6	// 指向底层循环数组的指针
 7	// 只针对有缓冲的 channel
 8	buf      unsafe.Pointer
 9	// chan 中元素大小
10	elemsize uint16
11	// chan 是否被关闭的标志
12	closed   uint32
13	// chan 中元素类型
14	elemtype *_type // element type
15	// 已发送元素在循环数组中的索引
16	sendx    uint   // send index
17	// 已接收元素在循环数组中的索引
18	recvx    uint   // receive index
19	// 等待接收的 goroutine 队列
20	recvq    waitq  // list of recv waiters
21	// 等待发送的 goroutine 队列
22	sendq    waitq  // list of send waiters
23
24	// 保护 hchan 中所有字段
25	lock mutex
26}

1ch := make(chan int)     // 无缓冲 channel
2ch := make(chan int, 10) // 有缓冲 channel，容量为10

 1// src/runtime/chan.go
 2func makechan(t *chantype, size int) *hchan {
 3	elem := t.Elem
 4
 5	// compiler checks this but be safe.
 6	if elem.Size_ >= 1<<16 {
 7		throw("makechan: invalid channel element type")
 8	}
 9	if hchanSize%maxAlign != 0 || elem.Align_ > maxAlign {
10		throw("makechan: bad alignment")
11	}
12
13	mem, overflow := math.MulUintptr(elem.Size_, uintptr(size))
14	if overflow || mem > maxAlloc-hchanSize || size < 0 {
15		panic(plainError("makechan: size out of range"))
16	}
17
18	// Hchan does not contain pointers interesting for GC when elements stored in buf do not contain pointers.
19	// buf points into the same allocation, elemtype is persistent.
20	// SudoG's are referenced from their owning thread so they can't be collected.
21	// TODO(dvyukov,rlh): Rethink when collector can move allocated objects.
22	var c *hchan
23	switch {
24	case mem == 0:
25		// 零内存需求（无缓冲或零大小元素）
26        // 只分配 hchan 结构体本身的内存
27		c = (*hchan)(mallocgc(hchanSize, nil, true))
28		// 竞态检测器使用这个位置进行同步
29		c.buf = c.raceaddr()
30	case elem.PtrBytes == 0:
31		// 元素不包含指针
32    	// 一次性分配 hchan 和 buf 的内存
33		c = (*hchan)(mallocgc(hchanSize+mem, nil, true))
34		c.buf = add(unsafe.Pointer(c), hchanSize)
35	default:
36		// 元素包含指针，分别分配 hchan 结构体和缓冲区内存
37		c = new(hchan)
38		c.buf = mallocgc(mem, elem, true)
39	}
40
41	c.elemsize = uint16(elem.Size_)
42	c.elemtype = elem
43	c.dataqsiz = uint(size)
44	lockInit(&c.lock, lockRankHchan)
45
46	if debugChan {
47		print("makechan: chan=", c, "; elemsize=", elem.Size_, "; dataqsiz=", size, "\n")
48	}
49	return c
50}

1ch <- value   // 发送值到 channel
2value := <-ch // 从 channel 接收值

1close(ch)     // 关闭 channel

 1func closechan(c *hchan) {
 2	if c == nil {
 3		panic(plainError("close of nil channel"))
 4	}
 5
 6	lock(&c.lock)
 7    // 幂等性检查：重复关闭已关闭的 channel 会 panic
 8	if c.closed != 0 {
 9		unlock(&c.lock)
10		panic(plainError("close of closed channel"))
11	}
12
13	if raceenabled {
14		callerpc := getcallerpc()
15		racewritepc(c.raceaddr(), callerpc, abi.FuncPCABIInternal(closechan))
16		racerelease(c.raceaddr())
17	}
18
19	c.closed = 1
20
21	var glist gList
22
23	// 处理接收队列 (recvq)
24	for {
25		sg := c.recvq.dequeue()
26		if sg == nil {
27			break
28		}
29		if sg.elem != nil {
30            // 清空接收数据：将接收者的 elem 置零（返回零值）
31			typedmemclr(c.elemtype, sg.elem)
32			sg.elem = nil
33		}
34		if sg.releasetime != 0 {
35			sg.releasetime = cputicks()
36		}
37		gp := sg.g
38		gp.param = unsafe.Pointer(sg)
39		sg.success = false
40		if raceenabled {
41			raceacquireg(gp, c.raceaddr())
42		}
43		glist.push(gp)
44	}
45
46	// 处理发送队列 (sendq)
47	for {
48		sg := c.sendq.dequeue()
49		if sg == nil {
50			break
51		}
52        // 清空发送数据：发送者的 elem 置 nil
53		sg.elem = nil
54		if sg.releasetime != 0 {
55			sg.releasetime = cputicks()
56		}
57		gp := sg.g
58		gp.param = unsafe.Pointer(sg)
59		sg.success = false
60		if raceenabled {
61			raceacquireg(gp, c.raceaddr())
62		}
63		glist.push(gp)
64	}
65	unlock(&c.lock)
66
67	// 批量唤醒 goroutine
68	for !glist.empty() {
69		gp := glist.pop()
70		gp.schedlink = 0
71		goready(gp, 3)
72	}
73}

 1func worker(done chan bool) {
 2    fmt.Println("working...")
 3    time.Sleep(time.Second)
 4    fmt.Println("done")
 5    done <- true
 6}
 7
 8func main() {
 9    done := make(chan bool)
10    go worker(done)
11    <-done // 等待worker完成
12}

 1func producer(ch chan<- int) {
 2    for i := 0; i < 10; i++ {
 3        ch <- i
 4    }
 5    close(ch)
 6}
 7
 8func consumer(ch <-chan int) {
 9    for num := range ch {
10        fmt.Println("Received:", num)
11    }
12}
13
14func main() {
15    ch := make(chan int, 5)
16    go producer(ch)
17    consumer(ch)
18}

 1select {
 2case msg1 := <-ch1:
 3    fmt.Println("received", msg1)
 4case msg2 := <-ch2:
 5    fmt.Println("received", msg2)
 6case ch3 <- 3:
 7    fmt.Println("sent 3")
 8default:
 9    fmt.Println("no communication")
10}

1select {
2case res := <-ch:
3    fmt.Println(res)
4case <-time.After(1 * time.Second):
5    fmt.Println("timeout")
6}

1func ping(pings chan<- string, msg string) { // 只发送channel
2    pings <- msg
3}
4
5func pong(pings <-chan string, pongs chan<- string) { // 接收和发送channel
6    msg := <-pings
7    pongs <- msg
8}