Channel 管道

1 初始化

可用var声明nil管道；用make初始化管道；

len()： 缓冲区中元素个数， cap()： 缓冲区大小

//变量声明 
var a chan int
//使用make初始化
b := make(chan int)  //不带缓冲区
c := make(chan string,2) // 带缓冲区

ch1 := make(chan int) // 0 0
ch2 := make(chan int, 2)// 1 2
ch2 <- 1
fmt.Println(len(ch1), len(ch2), cap(ch1), cap(ch2))

2 读写操作

用 " <- "来表示数据流向，缓冲区满时写/缓冲区空时读 都会阻塞，直到被其他携程唤醒

a := make(chan int, 3)
a <- 1 //数据写入管道
<-a    //管道读出数据

管道默认双向可读写，但也可在创建函数时显示单向读写

func write(ch chan<- int,a int)  {
	ch <- a
	// <- ch  无效运算: <- ch (从仅发送类型 chan<- int 接收)
}

func read(ch <-chan int)  {
	<- ch
	//ch <- 1  无效运算: ch <- 1 (发送到仅接收类型 <-chan int)
}

读写值为nil的管道，会永久阻塞，触发死锁

	var ch chan int
	ch <- 1  // fatal error: all goroutines are asleep - deadlock!
	<-ch  	 // fatal error: all goroutines are asleep - deadlock!

读写已关闭管道：有缓冲区成功可读缓冲区内容，无缓冲区读零值并返回false；写已关闭管道会触发panic

关闭后，等待队列中的携程全部唤醒，按照上述规则直接返回

ch1 := make(chan int)
ch2 := make(chan int, 2)
go func() {
	ch1 <- 1
}()
ch2 <- 2
close(ch1)
close(ch2)
v1, b1 := <-ch1  //0 false
v2, b2 := <-ch2  //2 true
println(v1, v2, b1, b2)
ch1 <- 1  //panic: send on closed channel
ch2 <- 1  //panic: send on closed channel

3 实现原理

简单来说，channel底层是通过环形队列来实现其缓冲区的功能。再加上两个等待队列来存除被堵塞的携程。最后加上互斥锁，保证其并发安全

type hchan struct {
qcount   uint           // 队列中数据的总数
dataqsiz uint           // 环形队列的大小
buf      unsafe.Pointer // 指向底层的环形队列
elemsize uint16         // 元素的大小（以字节为单位）
closed   uint32         // 表示通道是否已关闭
elemtype *_type         // 元素的类型（指向类型信息的指针）
sendx    uint           // 写入元素的位置
recvx    uint           // 读取元素的位置
recvq    waitq          // 等待接收的队列（包含等待接收的 goroutine）
sendq    waitq          // 等待发送的队列（包含等待发送的 goroutine）

// lock 保护 hchan 中的所有字段，以及阻塞在这个通道上的 sudogs 中的几个字段。
// 在持有此锁时，不要更改另一个 G 的状态（特别是不要使 G 变为可运行状态），
// 因为这可能会与栈收缩操作发生死锁。
lock mutex //互斥锁
}

环形队列是依靠数组实现的（buf指向该数组），实现方法类似双指针：一个指向写入位置（sendx），一个指向读取位置（recvx）

等待队列遵循先进先出，阻塞中的携程会被相反的操作依次唤醒

如果写入时，等待接收队列非空(recvq),那么直接将数据给到等待的携程，不用经过缓冲区

select可以监控单/多个管道内是否有数据，有就将其读出；没有也不会阻塞，直接返回；

select执行顺序是随机的

func main() {
	ch1 := make(chan int)
	ch2 := make(chan int)
	go write(ch1)
	go write(ch2)
	for {
		select {
		case e := <-ch1:
			fmt.Printf("ch1:%d\n", e)
		case e := <-ch2:
			fmt.Printf("ch2:%d\n", e)
		default:
			fmt.Println("none")
			time.Sleep(1 * time.Second)
		}
	}
}
func write(ch chan<- int) {
	for {
		ch <- 1
		time.Sleep(time.Second)
	}
}

for-range 读取管道时，管道关闭之后不会继续读取管道内数据；

for 循环读取管道时，管道关闭后，仍会继续读取管道内的数据，返回一堆 零值,false

func main() {
   ch1 := make(chan int)
   go write(ch1)
   //for e := range ch1 { // 关闭后不会再从管道读取数据
   //	fmt.Print(e)
   //}
   //1111
   
   for { // 关闭后仍在从管道读取数据。返回 零值,false
   fmt.Print(<-ch1)
   }
   //11110000000000000000000000000000000000000.....
}
func write(ch chan<- int) {
   for i := 1; i < 5; i++ {
   ch <- 1
   time.Sleep(time.Second)
   }
   close(ch)
}