golang 重要知识：channel 用法和底层原理

最新推荐文章于 2024-10-11 19:42:45 发布

yue_xin_tech

最新推荐文章于 2024-10-11 19:42:45 发布

阅读量6.3k

点赞数

分类专栏：开发 All golang

本文链接：https://blog.csdn.net/h_l_f/article/details/118255931

版权

开发 All 同时被 2 个专栏收录

37 篇文章 0 订阅

订阅专栏

golang

15 篇文章 1 订阅

订阅专栏

前言

channel 是 goroutine 与 goroutine 之间通信的重要桥梁，借助 channel，我们能很轻易的写出一个多协程通信程序。今天，我们就来看看这个 channel 的常用用法以及底层原理。

一、channel 的概念

channel 是一个通道，用于端到端的数据传输，这有点像我们平常使用的消息队列，只不过 channel 的发送方和接受方是 goroutine 对象，属于内存级别的通信。

这里涉及到了 goroutine 概念，goroutine 是轻量级的协程，有属于自己的栈空间。我们可以把它理解为线程，只不过 goroutine 的性能开销很小，并且在用户态上实现了属于自己的调度模型。

传统的线程通信有很多方式，像内存共享、信号量等。其中内存共享实现较为简单，只需要对变量进行并发控制，加锁即可。但这种在后续业务逐渐复杂时，将很难维护，耦合性也比较强。

后来提出了 CSP 模型，即在通信双方抽象出中间层，数据的流转由中间层来控制，通信双方只负责数据的发送和接收，从而实现了数据的共享，这就是所谓的通过通信来共享内存。 channel 就是按这个模型来实现的。

channel 在多并发操作里是属于协程安全的，并且遵循了 FIFO 特性。即先执行读取的 goroutine 会先获取到数据，先发送数据的 goroutine 会先输入数据。

另外，channel 的使用将会引起 Go runtime 的调度调用，会有阻塞和唤起 goroutine 的情况产生。

二、channel 的使用

在深入了解 channel 的底层之前，我们先来看看 channel 的常用用法。

channel 的创建

	ch := make(chan int)

上面是创建了无缓冲的 channel，一旦有 goroutine 往 channel 发送数据，那么当前的 goroutine 会被阻塞住，直到有其他的 goroutine 消费了 channel 里的数据，才能继续运行。

还有另外一种是有缓冲的 channel，它的创建是这样的:

ch := make(chan int, 2)

第二个参数表示 channel 可缓冲数据的容量。只要当前 channel 里的元素总数不大于这个可缓冲容量，则当前的 goroutine 就不会被阻塞住。

需要注意的是，上面 make 后返回的是一个指向 hchan 结构的指针变量，等会将会聊聊 hchan 的底层结构。

另外，我们也可以声明一个 nil 的 channel，只是创建这样的 channel 没有意义，读、写 channel 都将会被阻塞住。一般 nil channel 用在 select 上，让 select 不再从这个 channel 里读取数据，如下用法：

	ch1 := make(chan int)
	ch2 := make(chan int)

	go func() {
		if !ok { // 某些原因，设置 ch1 为 nil
			ch1 = nil
		}
	}()

	for {
		select {
		case <-ch1: // 当 ch1 被设置为 nil 后，将不会到达此分支了。
			doSomething1()
		case <-ch2:
			doSomething2()
		}
	}

使用 channel 时我们还可以控制 channel 只读只写操作：

	func readChan(ch <-chan int){
		// chan 只允许被读
	}

	func main(){
		ch := make(chan int)
		readChan(ch)
	}

反之，如果要求只写操作，则可以这样：

	func writeChan(ch chan<- int){
	    // chan 只允许被写
	}

channel 的读写

往一个 channel 发送数据，可以这样写：

	ch := make(chan int)
	ch <- 1

对应的读操作：

	data <- ch

当我们不再使用 channel 的时候，可以对其进行关闭：

	close(ch)

当 channel 被关闭后，如果继续往里面写数据，则程序会直接 panic 退出。

不过读取关闭后的 channel，不会产生 pannic，还是可以读到数据。

如果关闭后的 channel 没有数据可读取时，将得到零值，即对应类型的默认值。

为了能知道当前 channel 是否被关闭，可以使用下面的写法来判断。

	if v, ok := <-ch; !ok {
		fmt.Println("channel 已关闭，读取不到数据")
	}

还可以使用下面的写法不断的获取 channel 里的数据：

	for data := range ch {
		// get data dosomething
	}

这种用法会在读取完 channel 里的数据后就结束 for 循环，执行后面的代码。

channel 和 select

在写程序时，有时并不单单只会和一个 goroutine 通信，当我们要进行多 goroutine 通信时，则会使用 select 写法来管理多个 channel 的通信数据：

	ch1 := make(chan struct{})
	ch2 := make(chan struct{})

	// ch1, ch2 发送数据
	go sendCh1(ch1)
	go sendCh1(ch2)

	// channel 数据接受处理
	for {
		select {
		case <-ch1:
			doSomething1()
		case <-ch2:
			doSomething2()
		}
	}

channel 的 deadlock

前面提到过，往 channel 里读写数据时是有可能被阻塞住的，一旦被阻塞，则需要其他的 goroutine 执行对应的读写操作，才能解除阻塞状态。

然而，阻塞后一直没能发生调度行为，没有可用的 goroutine 可执行，则会一直卡在这个地方，程序就失去执行意义了。此时 Go 就会报 deadlock 错误，如下代码：

	func main() {
		ch := make(chan int)
		<-ch

		// 执行后将 panic：
		// fatal error: all goroutines are asleep - deadlock!
	}

因此，在使用 channel 时要注意 goroutine 的一发一取，避免 goroutine 永久阻塞！

三、channel 的底层原理

前面提及过 channel 创建后返回了 hchan 结构体，现在我们来研究下这个结构体，它的主要字段如下：

type hchan struct {
	qcount   uint   // channel 里的元素计数
	dataqsiz uint   // 可以缓冲的数量，如 ch := make(chan int, 10)。 此处的 10 即 dataqsiz
	elemsize uint16 // 要发送或接收的数据类型大小
	buf      unsafe.Pointer // 当 channel 设置了缓冲数量时，该 buf 指向一个存储缓冲数据的区域，该区域是一个循环队列的数据结构
	closed   uint32 // 关闭状态
	sendx    uint  // 当 channel 设置了缓冲数量时，数据区域即循环队列此时已发送数据的索引位置
	recvx    uint  // 当 channel 设置了缓冲数量时，数据区域即循环队列此时已接收数据的索引位置
	recvq    waitq // 想读取数据但又被阻塞住的 goroutine 队列
	sendq    waitq // 想发送数据但又被阻塞住的 goroutine 队列

	lock mutex
	...
}