go channel 使用及机制流程汇总

协程间通讯的普通使用, 发送值给 channel , 外部 channel 接收.

func t1() {
	ch := make(chan int)
	go func() {
		ch <- 1
	}()

	// <-ch // 导致下面语句阻塞
	fmt.Println("channel int", <-ch)
}
复制代码

channel int 1
复制代码

channel 支持缓冲区

func t2() {
	ch := make(chan int, 3)
	go func() {
		ch <- 1
		ch <- 2
		ch <- 3
		ch <- 4 // 会阻塞写不入, 除非ch已接收
		close(ch) // 关闭后不能再写入, 并且缓冲区内为空时则返回零值
	}()
	fmt.Println("buffer channel int",
		<-ch,
		<-ch,
		<-ch,
		<-ch,
		<-ch)
}
复制代码

buffer channel int 1 2 3 4 0
复制代码

select 是专门给管道定制

func t3() {
	ch1 := make(chan int)
	ch2 := make(chan struct{})

	go func() {
		ch1 <- 2
	}()

	select {
	case <-ch1:
		fmt.Println("select here is ch1")
	case <-ch2:
		fmt.Println("select here is ch2")
	}
}
复制代码

select here is ch1
复制代码

使用 for

func t4() {
	ch := make(chan int, 5)

	go func() {
		for i:=1; i<=5; i++ {
			time.Sleep(time.Millisecond * 10)
			ch <- i
		}
	}()

	for v := range ch {	// 会阻塞
		fmt.Println("for channel ", v)
		if v == 5 {
			break
		}
	}
}
复制代码

for channel  1
for channel  2
for channel  3
for channel  4
for channel  5
复制代码

同时使用 select 和 for

func t5() {
	chPrint := make(chan struct{}) 
	chStop := make(chan struct{}) 

	go func(){
		time.Sleep(time.Second * 1)
		chPrint <- struct{}{}

		time.Sleep(time.Second * 1)
		chPrint <- struct{}{}

		time.Sleep(time.Second * 1)
		chStop <- struct{}{}
	}()

	var sum int
	for {
		time.Sleep(time.Millisecond)

		select {
		case <-chPrint:
			fmt.Println("for+select now is", sum)
		case <-chStop:
			fmt.Println("for+select stop, result is", sum)
			return
		default:
			if sum == 10000 {
				fmt.Println("for+select end, result is", sum)
				return
			}
			sum += 1
		}
	}
}
复制代码

for+select now is 766
for+select now is 1540
for+select stop, result is 2309
复制代码

判断管道是否关闭

func t6() {
	ch := make(chan struct{})

	go func() {
		close(ch)
		//ch <- struct{}{} // 只运行这句, 输出OK
	}()
	if _, ok := <-ch; ok {
		fmt.Println("if channel is ok")
		return
	}
	fmt.Println("if channel is bad")
}
复制代码

if channel is bad
复制代码

以只发送或只接收为传递参数, 同理也可以为返回值

func t7() {
	ch := make(chan struct{})
	chExit := make(chan struct{})

	go func(chRecv <-chan struct{}) {
		fmt.Println("recv channel")
		<-chRecv
		chExit<- struct{}{}
	}(ch)

	go func(chSend chan<- struct{}) {
		fmt.Println("send channel")
		chSend <- struct{}{}
	}(ch)

	<-chExit
}
复制代码

send channel
recv channel
复制代码

channel机制流程汇总

makechan() 初始化 hchan 结构体, 如果没有缓冲区即分配 hchanSize 大小的内存并返回;而有缓冲区的情况下, 则计算管道元素类型大小并分配 hchanSize +( elem.size * size )大小的内存(缓冲区是一个环形的结构设计), 最后返回 hchan .