go并发编程| channel入门

channel

介绍

channel 是在 Go 的并发编程中使用的，这个工具的作用之一是 goroutine 之间通信（线程通信指的是多个线程之间通过共享数据或协作机制来协调操作，通常需要借助锁来保证同步）。Go 中推荐使用 channel（不同语言有不同的并发模型，例如 Java 使用共享内存并发模型，通过锁机制和条件变量实现线程间通信）。为什么是推荐呢？因为不用 channel，也可以用共享内存的方式进行通信，但这并不推荐（例如使用 sync.Mutex、sync.Map 等进行并发控制，虽然也能实现功能，但更容易出错、调试困难，违背了 Go “通过通信来共享内存”的设计理念），这里不展开。

• 共享内存模式 就像是多人在同一个白板上写字，需要规矩（锁）来约定谁能写。
• channel 模式 像是每人写好纸条，通过信封（channel）传递，彼此之间不直接碰同一个白板，避免冲突。

一句话总结：没有那么复杂，channel就是一个官方写好的数据结构，用来线程通信，很安全，放心用。

它的底层已经帮你封装好了：

• 带缓冲的 channel：用环形队列存数据；
• 不带缓冲的 channel：发送和接收必须同步进行；
• 内部用 锁（Mutex）和等待队列 保证并发安全。

使用

使用make初始化，eg.make(chan int)，后面要跟一个类型，就是channel中放置的数据类型。

<-ch是只读管道，ch<-是只进管道，ch是双端管道

	ch := make(chan int, 2)go func() {for i := 0; i < 3; i++ {ch <- i + 1}close(ch)}()for i := range ch {// for中i就是管道中的值fmt.Println(i)}

channel具有阻塞的特点，也就是如果在取ch时无数据，当前goroutine会阻塞，如果当前ch满了还往里面放数据，当前goroutine也会阻塞在里面。

利用这个阻塞的特点，可以实现并发线程数量的控制，并发顺序的控制：

	ch := make(chan int)// 这样goroutine只有结束后，主goroutine才会继续执行go func() {for i := 0; i < 3; i++ {fmt.Println(i)}ch <- 1}()<-ch

控制并发数量：

func TestName(t *testing.T) {ch := make(chan int, 5)wg := sync.WaitGroup{}for i := 0; i < 30; i++ {wg.Add(1)go func(i int) {ch <- 1defer wg.Done()defer func() { <-ch }() // defer必须调用一个函数fmt.Println(i)time.Sleep(1 * time.Second)}(i)}wg.Wait()
}

ch可以作为全局变量也可以作为参数传导，不过网上很多都推荐作为参数传递：

func doWork(i int, ch chan int, wg *sync.WaitGroup) {ch <- 1 // 获取令牌defer func() {<-ch // 释放令牌wg.Done()}()fmt.Println(i)time.Sleep(1 * time.Second)
}func TestName(t *testing.T) {ch := make(chan int, 5)var wg sync.WaitGroupfor i := 0; i < 30; i++ {wg.Add(1)// wg是值类型，所以要取指针，ch本身就是指针，所以不用再取指针了go doWork(i, ch, &wg)}wg.Wait()
}

解释一下为什么不用传指针：Go 中的 channel（chan int 这种类型）在语义上是引用类型，其底层是一个指向 hchan 结构体的指针，所以在函数间传递 channel 实际上传的是指针的副本，多个函数操作的都是同一个 channel 实例。

原理

一句话总结：Go 的 channel 本质是一个线程安全的通信结构，底层是 hchan 结构体，借助环形缓冲区 + 双向队列 + 互斥锁 + 原子操作实现 协程间的通信与同步。

---

解释：

chan T 在底层对应的是 runtime.hchan 结构体，源码在 runtime/chan.go。

type hchan struct {qcount   uint           // 队列中当前元素个数dataqsiz uint           // 队列容量buf      unsafe.Pointer // 环形队列缓冲区起始地址elemsize uint16         // 元素大小closed   uint32         // 是否关闭sendx    uint           // 发送索引（环形队列位置）recvx    uint           // 接收索引（环形队列位置）recvq    waitq          // 等待接收的 goroutine 队列sendq    waitq          // 等待发送的 goroutine 队列lock     mutex          // 保证并发安全的锁
}

channel 在底层都是一个 hchan 结构体。当是带缓冲的 channel 时，它内部会维护一个环形队列用于缓存数据；当是无缓冲的 channel 时，数据只能在发送方和接收方同时存在时直接传递，不经过缓冲区。在多 goroutine 并发使用时，channel 的所有操作都由互斥锁（mutex）保护，以确保线程安全。

缓冲时的环形结构图：

buf: [v0, v1, v2, v3, v4]↑          ↑recvx      sendx

非缓冲时：

对于无缓冲 channel（make(chan T)）：

• 没有 buf。
• 发送方必须等待接收方同时准备好，才能发送成功，真正的同步通信。
• 否则发送方会被挂起，进入 sendq 等待队列。

发送操作的伪代码：

func send(ch *hchan, val T) {lock(ch.lock) // ① 加锁，保证并发安全if ch.closed {panic("send on closed channel") // ② 关闭的 channel 不允许发送}if receiver := ch.recvq.dequeue(); receiver != nil {// ③ 有接收者在等，直接将值拷贝给接收者，唤醒它receiver.value = valready(receiver)} else if ch.qcount < ch.dataqsiz {// ④ 缓冲区未满，放入缓冲区ch.buf[ch.sendx] = valch.sendx = (ch.sendx + 1) % ch.dataqsizch.qcount++} else {// ⑤ 缓冲区已满，无接收者 —— 当前 sender 入队并阻塞enqueue(ch.sendq, currentGoroutine)park() // 将当前 goroutine 挂起}unlock(ch.lock) // ⑥ 解锁
}

接收操作的伪代码：

func recv(ch *hchan) (val T, ok bool) {lock(ch.lock) // ① 加锁if ch.qcount > 0 {// ② 缓冲区有数据，从缓冲区读取val = ch.buf[ch.recvx]ch.recvx = (ch.recvx + 1) % ch.dataqsizch.qcount--unlock(ch.lock)return val, true}if sender := ch.sendq.dequeue(); sender != nil {// ③ 有发送者在等，直接从 sender 拿值，唤醒 senderval = sender.valueready(sender)unlock(ch.lock)return val, true}if ch.closed {// ④ channel 已关闭，返回零值，ok = falseunlock(ch.lock)return zeroValue(T), false}// ⑤ 没人发，缓冲区也空，当前 receiver 入队并阻塞enqueue(ch.recvq, currentGoroutine)park() // 挂起当前 goroutine，等待唤醒unlock(ch.lock)// 被唤醒时，会从其他 sender 处获取 valreturn val, true
}

小问题

问题	解答
channel 是值类型还是引用类型？	引用类型，传的是底层 hchan 指针
无缓冲 channel 怎么通信？	发送和接收必须同时准备好（同步通信）
关闭 channel 会怎样？	再次关闭会 panic；读取会读到零值且 ok==false
发送到关闭的 channel？	panic
从关闭的 channel 读取？	如果还有数据没读完：正常返回数据。如果已经读完了：返回该类型的零值 + ok == false。
是否可以判断 channel 是否满？	不行，channel 没有 len() 和 cap() 外的并发判断能力
channel 会内存泄漏吗？	如果 goroutine 被卡在 send/recv 而没人唤醒，会泄漏