https://a18792721831.github.io/

1. 基本知识

chan是go里面里面提供的语言层面的协程间的通信方式，用于并发通信。

1.1 定义

• 变量声明: var ch chan int // 声明一个int型的chan
  这种方式声明的chan，值为nil。并且每一种chan只能有一种类型。
• make声明: ch1 := make(chan int)// 无缓存的chan，ch2 := make(chan int, 4)// 有缓冲的chan

1.2 操作

操作符<-表示数据流向，当chan在<-左边，表示数据流向chan，也就是向chan写入数据；当chan在<-右边，表示数据流出chan，
也就是从chan读取数据。

func TestChanOne(t *testing.T) {
	var ch chan int
	ch = make(chan int) // 无缓冲chan
	go func() {         // 创建一个协程，不断从chan中读取数据
		<-ch
	}()
	ch <- 1 // 写入数据，因为没有缓冲，如果没有上面那句，这句会阻塞

	var ch1 chan int
	ch1 = make(chan int, 1) // 有缓冲chan
	ch1 <- 2                // 因为有缓存，所以这句不会阻塞，但是因为缓冲长度是1，所以在写入就会阻塞
	fmt.Printf("len=%d, cap=%d\n", len(ch1), cap(ch1))
	fmt.Println(<-ch1) // 读取数据，因为有缓冲，并且有数据，所以不会阻塞
}

执行结果：

1.3 操作限定

默认的chan为双向可读写，chan在函数间传递的时候，可以使用操作符限制chan的读写。

func ChanRW(ch chan int) {
	ch <- 1
	<-ch
}

func ChanR(ch <-chan int) {
	ch <- 1
	<-ch
}

func ChanW(ch chan<- int) {
	ch <- 1
	<-ch
}

1.4 chan 读写

chan无缓冲时，从chan读取数据会阻塞，直到有协程向chan写入数据。向chan写入数据也会阻塞，直到有协程读取数据。
chan有缓冲时，从chan读取数据，如果缓冲区中没有数据，那么也会阻塞，直到有协程写入数据。向chan写入数据，如果缓冲区已经满了，也会阻塞，直到有协程从chan中读取数据。
对于nil的chan,不管是读还是写，都是永久阻塞。 – 这个一定注意。
使用内置函数close可以关闭chan，尝试向关闭的chan写入数据会触发panic，但是仍然可以读取。
chan读取最多可以给两个变量赋值:

  i := <- ch
  j, ok := <- ch

第一个变量表示读取的值，第二个变量表示是否成功读取了数据。第二个变量不表示chan是否关闭。
对于关闭的有缓冲的chan存在两种情况：1. 缓冲区中没有数据; 2. 缓冲区中有数据。
对于有缓冲的chan并且用内置函数close进行关闭，在继续读取，针对缓冲区中没有数据，读取的第一个值是该类型的零值，第二个值为false，表示没有成功读取数据。
如果缓冲区中存在数据，那么第一个值是缓冲区中的第一个数据，第二个值是true，表示正确读取到数据。

也就是说，只有缓冲区中没有数据了，第二个值才能代表chan已经关闭。
当chan没有缓冲区的时候，第二个值可以认为是chan的关闭状态。

2. 原理

2.1 数据结构

在源码包的src/runtime/chan.go中定义了chan的结构：

type hchan struct {
	qcount   uint           // 当前队列中剩余的元素个数
	dataqsiz uint           // 环形队列的长度，即可以存放的元素个数
	buf      unsafe.Pointer // 环形队列指针
	elemsize uint16         // 每个元素的大小
	closed   uint32         // 关闭状态
	elemtype *_type         // 元素类型
	sendx    uint           // 写入位置
	recvx    uint           // 读取位置
	recvq    waitq          // 阻塞读协程队列
	sendq    waitq          // 阻塞写协程队列
	lock     mutex          // 互斥锁
}

可以看出，一个chan基本上由数据缓冲，类型信息，和协程等待队列组成。

2.2 环形队列

环形队列主要是存储缓冲数据的，其实实现一个缓冲队列非常简单，只需要一个数组就能实现，每次数组指针到达最后一个元素，那么就重置为0即可。

	var data []int
	data = make([]int, 10)
	for i := 0; i < 100; i++ {
		data[i] = i
		if i == len(data)-1 {
			i = 0
		}
	}

上面的if就是实现了环形队列，所以名字叫做环形队列，实际上可能是线性的结构。
在chan中使用双指针实现读取和写入数据，读指针表示读取的元素位置，写指针表示写入的元素位置。
当读指针等于写指针的时候，表示数据读取完毕，整个队列为空。
当写指针等于读指针的时候，表示队列满，无法写入。

2.3 等待队列

因为同一个chan可以传给多个协程，就会出现多个协程等待读取的情况；对于写数据也是相同的，那么此时就会根据先后顺序，组成等待队列，等待的协程组成了读阻塞队列和写阻塞队列。
当对chan进行写操作，那么唤醒读队列的协程；当对chan进行读操作，那么唤醒写队列的协程。
对于chan进行写操作，如果读协程队列为空，那么写操作阻塞；对于chan进行读操作，如果写协程队列为空，那么读操作阻塞。

需要注意，上述情况还有一个附件条件：无缓冲chan，如果是有缓冲chan，那么对于写操作，缓冲区满，对于读操作，缓冲区空。

2.4 类型消息

在chan的定义中，保存了类型消息和类型长度，类型消息主要是传递过程中赋值，类型长度主要是计算缓冲区中元素的位置。

2.5 读写数据

对于chan读写数据，实际上就是数据进入缓冲区和读出缓冲区的操作。
在实现上则存在一定的技巧：
写入数据时，如果读协程等待队列不为空，那么直接将数据给读协程等待队列的第一个协程即可，不进行数据缓冲区的数据写入，然后在唤醒，最后读取的操作，避免了数据的额外处理。
同样的，读取数据时，需要甄别一下，因为chan本质上是队列，需要符合先入先出的规则，在写入数据时，因为chan为空，所以不管有没有缓冲区，都可以直接将数据交给等待的读取协程。
但是在读取数据的时候，如果存在缓冲区，那么就必须从缓冲区中读取，读取数据后，环形写入协程等待队列，将数据写入缓冲区的队尾。
只有无缓冲区的chan，才可以直接从写等待协程队列中唤醒协程，并将数据直接交给读取协程。

2.6 关闭chan

关闭chan的时候，会将读等待队列和写等待队列的全部协程都唤醒。
对于读等待的协程，赋值该类型的零值，并且将第二个值赋值为false。

需要注意，对于chan，不会同时既存在读等待队列协程，又存在写等待队列协程。(长时间同时，瞬时的同时可能存在)

对于写等待的协程，直接触发panic，向close的chan写入数据，直接panic。
除此之外，这些操作也会panic:

• 关闭nil的chan
• 关闭已经关闭的chan
• 向已经关闭的chan写入数据

3. 使用

3.1 操作符使用

使用<-进行操作，同时也可以限制在当前函数范围内chan的操作方式，读还是写，还是读写。

3.2 select

对于chan的使用，不管是读取还是写入，非常导致阻塞，但是很多时候，我们又不希望整个程序阻塞，因为是并发的，可能当前chan没有数据，但是别的chan可能有数据，那么就可以在等待一个chan的时候，处理其他chan的数据，增加程序的性能。
使用select就可以实现监控多个chan。

	sayOne := make(chan string)
	sayTwo := make(chan string)
	// 每两秒发送 one
	go func() {
		for {
			sayOne <- "one"
			time.Sleep(2 * time.Second)
		}
	}()
	// 每两秒发送 two
	go func() {
		for {
			sayTwo <- "tow"
			time.Sleep(2 * time.Second)
		}
	}()
	for {
		// 如果 select 中的任何 case 都没有触发，那么 select 本身是会阻塞的，直到某个 case 触发
		select {
		case msg := <-sayOne:
			fmt.Println(msg)
		case msg := <-sayTwo:
			fmt.Println(msg)
		// 但是因为 select 触发的 case 是随机的，所以这里可能并不会正确执行第三个case 	
		case <-time.After(10 * time.Second):
			return
		}
	}

要想按照程序10秒后退出，可以使用定时器进行超时退出：

	// 设置超时
	time.AfterFunc(10*time.Second, func() {
		os.Exit(0)
	})

除此之外，还可以使用default进行计时，然后进行超时退出操作。

	sayOne := make(chan string)
	sayTwo := make(chan string)
	// 每两秒发送 one
	go func() {
		for {
			sayOne <- "one"
			time.Sleep(2 * time.Second)
		}
	}()
	// 每两秒发送 two
	go func() {
		for {
			sayTwo <- "tow"
			time.Sleep(2 * time.Second)
		}
	}()
	// 设置超时
	//time.AfterFunc(10*time.Second, func() {
	//	os.Exit(0)
	//})
	tm := 0
	for {
		// 如果 select 中的任何 case 都没有触发，那么 select 本身是会阻塞的，直到某个 case 触发
		select {
		case msg := <-sayOne:
			fmt.Println(msg)
		case msg := <-sayTwo:
			fmt.Println(msg)
			// 但是因为 select 触发的 case 是随机的，所以这里可能并不会正确执行第三个case
		//case <-time.After(10 * time.Second):
		//	return
		default:
			if tm == 10 {
				return
			}
			time.Sleep(time.Second)
			tm++
		}
	}

3.3 for-range

使用<-操作符可以读取数据，除了使用<-操作符，还可以使用for-range进行数据的读取，就像读取一个数组一样。

	ch := make(chan int, 10)
	for i := 0; i < 10; i++ {
		ch <- i
	}
	for i := range ch {
		fmt.Println(i)
	}

使用for-range还有个好处，就是读取的数据都是成功的，不用去考虑数据是否读取成功，同时也不用考虑当chan关闭，当chan关闭后，for-range也能正确的处理。

	ch := make(chan int, 10)
	for i := 0; i < 10; i++ {
		ch <- i
	}
	// 5秒后关闭chan
	time.AfterFunc(5*time.Second, func() {
		close(ch)
	})
	// 每一秒读取一个元素
	for i := range ch {
		fmt.Println(i)
		time.Sleep(time.Second)
	}

即使第5秒的时候，chan被关闭了，也可以正确的读取全部的数据。