golang channel select 使用

凄魅旋律

已于 2022-07-10 17:43:59 修改

阅读量975

点赞数 1

分类专栏： golang 文章标签： golang 开发语言后端

于 2022-07-10 17:34:22 首次发布

本文链接：https://blog.csdn.net/lu4506527/article/details/125668082

版权

golang 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

chan管道是多个goroutine进行通信的一种方式，跟linux中管道一样，linux中进程之间的通讯使用管道，管道遵循"先进后出"原则

1. channel的使用场景

消息传递、消息过滤
信号广播
消息传递、消息过滤
事件订阅与广播
请求、响应转发
任务分发
结果汇总
并发控制
同步与异步

2. channel存在3种状态

nil，未初始化的状态，只进行了声明，或者手动赋值为nil
active，正常的channel，可读或者可写
closed，已关闭，千万不要误认为关闭channel后，channel的值是nil

3. channel可进行3种操作

读、写、关闭
把这3种操作和3种channel状态可以组合出9种情况：在这里插入图片描述

4. 无缓冲chan管道-先读后写

package main
import "fmt"
func main() {
	// 定义int channel，无缓冲
	c := make(chan int)
	// 创建一个goroutine
	go func() {
		defer fmt.Println("goroutine 结束")
		fmt.Println("goroutine 正在运行...")
		// 往c管道中写入数据
		c <- 666
	}()
	// 从c中读取数据，并且复制给num。
	num := <-c  
	fmt.Println("num = ", num)
	fmt.Println("main goroutine 结束...")
}

num := <-c 这里会发生阻塞直到有写操作时才会往下执行。也就是管道没有数据时，读操作会阻塞。直到有一方往里写数据了，才会往下执行。总结：读数据时，如果没有数据会发生阻塞

5. 无缓冲chan管道-先写后读

package main
import (
	"fmt"
	"time"
)
func main() {
	// 定义int channel，无缓冲
	c := make(chan int)
	// 创建一个goroutine
	go func() {
		defer fmt.Println("goroutine 结束")
		fmt.Println("goroutine 正在运行...")
		// 往c管道中写入数据
		c <- 666
		fmt.Println("已经往管道写数据")
	}()
	// 这里sleep3秒
	time.Sleep(time.Second * 3)
	// 从c中读取数据，并且复制给num。
	num := <-c // 注意这里会阻塞直到有写操作时才会往下执行，也就是管道没有数据时，读操作会阻塞。直到有一方往里写数据了，

	// 为了主程不要结束那么快
	time.Sleep(time.Second * 1)
	fmt.Println("num = ", num)
	fmt.Println("main goroutine 结束...")
}

c <- 666 当我们再往管道写数据的时候，是阻塞的。因为这时候没有人读数据，直到3秒之后，主go程执行，读取管道里的数据，这时候，c <- 666 才会往下执行，打印出"已经往管道写数据"。结论：写数据时，如果没有人读取数据，会阻塞

5. 有缓冲chan管道

package main
import (
	"fmt"
	"time"
)
func main() {
	// 定义有缓冲的channel，容量为3
	c := make(chan int, 3)
	go func() {
		defer fmt.Println("子go程结束...")
		for i := 0; i < 3; i++ {
			c <- i
			fmt.Println("子go程正在运行,发送的元素=", i, "len(c)=", len(c), "cap(c)=", cap(c))
		}
	}()
	//睡眠一下，让子go写完数据
	time.Sleep(2 * time.Second)

	for i := 0; i < 3; i++ {
		num := <-c
		fmt.Println("num=", num)
	}
	fmt.Println("main 结束")
}

子go先往 c 里写3个数据，因为是有缓冲的，所以写入3个的时候，不会等待。2秒之后，主go程读取管道数据，并打印。

有缓冲的管道，在容量没有满的时候，往里写数据，是不会阻塞的。容量满的话，就会阻塞，直到有空的位置出来
如果读取超出容量时会报错，比如容量为3，但是for循环的时候循环了4次，这时候就会报错

5. 关闭chan

package main

import "fmt"

func main() {
	c := make(chan int)
	go func() {
		for i := 0; i < 5; i++ {
			c <- i
		}
		// 关闭管道
		close(c)
	}()
	// 主go程读取数据
	for {
		// ok 如果为true 表示channel没有关闭，如果为false表示channel已经关闭
		if data, ok := <-c; ok {
			fmt.Println(data)
		} else {
			// 关闭了，跳出循环
			break
		}
	}
	fmt.Println("main finished..")
}

channel不像文件一样要经常关闭，只有当你确定没有数据发送了，才去关闭channel
关闭channel后，无法向chanel再发送数据(会引发panic错误后导致)
关闭channel后，可以继续从channel读取数据
对于nil（没有make）的channel，无论读写都发会发生阻塞

6. 遍历chan rang

package main
import (
	"fmt"
	"time"
)
func main() {
	c := make(chan int)
	go func() {
		for i := 0; i < 5; i++ {
			time.Sleep(1 * time.Second)
			c <- i
		}
		// 关闭管道
		close(c)
	}()
	// 主go程读取数据
	//for {
	//	// ok 如果为true 表示channel没有关闭，如果为false表示channel已经关闭
	//	if data, ok := <-c; ok {
	//		fmt.Println(data)
	//	} else {
	//		// 关闭了，跳出循环
	//		break
	//	}
	//}
	// 从c中读取数据，如果没有数据就会阻塞等待数据的到来
	for data := range c {
		fmt.Println(data)
	}
	fmt.Println("main finished..")
}

使用range跟for一样的效果，range更加简洁。如果在其他协程中调用了close(ch),那么就会跳出for range循环。这也就是for range的特别之处

6.chan select

select功能：在多个通道上进行读或写操作，让函数可以处理多个事情，但1次只处理1个。以下特性也都必须熟记于心：

每次执行select，都会只执行其中1个case或者执行default语句。
当没有case或者default可以执行时，select则阻塞，等待直到有1个case可以执行。
当有多个case可以执行时，则随机选择1个case执行。
case后面跟的必须是读或者写通道的操作，否则编译出错。

go 的select 类似linux的IO多路复用中的select事件

package main
import "fmt"
func main() {
	readCh := make(chan int, 1)
	writeCh := make(chan int, 1)
	y := 1
	select {
	case x := <-readCh:
		fmt.Printf("Read %d\n", x)
	case writeCh <- y:
		fmt.Printf("Write %d\n", y)
	default:
		fmt.Println("Do what you want")
	}
}

我们创建了readCh和writeCh2个通道：

readCh中没有数据，所以case x := <-readCh读不到数据，所以这个case不能执行。
writeCh是带缓冲区的通道，它里面是空的，可以写入1个数据，所以case writeCh <- y可以执行。
有case可以执行，所以default不会执行。

7.chan select 配合使用：

同时监听不同的channel，做同一件工作，可以最快的返回结果。

package main

import (
	"fmt"
	"net/http"
)
var q = make(chan int)
var reqNum = 0
func main() {
	// 无缓冲chan
	ch1 := make(chan int)
	ch2 := make(chan int)
	ch3 := make(chan int)

	go getUrlData("https://www.baidu.com/", ch3)
	go getUrlData("https://www.baidu.com/", ch2)
	go getUrlData("https://www.baidu.com/", ch1)

	for {
		// 注意：如果3个ch都同时可读的话，select只会随机取一个。那剩下2个需要依靠for再次去读取
		select {
		case v := <-ch1:
			fmt.Println(v)
		case v := <-ch2:
			fmt.Println(v)
		case v := <-ch3:
			fmt.Println(v)
		case n := <-q:
			// 3次请求之后，退出for循环
			if n >= 3 {
				return
			}
		default:
			continue
		}
	}
	fmt.Println("循环结束")
}
func getUrlData(url string, ch chan int) {
	req, err := http.Get(url)
	if err == nil {
		ch <- req.StatusCode
		reqNum += 1
		q <- reqNum
	} else {
		fmt.Println(err)
	}
}

select 时 chan关闭

package main

import (
	"fmt"
	"time"
)
func main() {
	c := make(chan interface{})
	go func() {
		time.Sleep(2 * time.Second)
		close(c)
	}()
	select {
	case _, ok := <-c:
		fmt.Printf("chan关闭：%v", ok)
	}
}

chan关闭时，第二个参数会返回false，可以根据返回值做响应的处理

在for 和select 配合使用中使用 break 退出循环是无效的，正确的做法如下：

package main
import (
	"fmt"
	"time"
)
func main() {
	chExit := make(chan bool)
	go func() {
		time.Sleep(2 * time.Second)
		close(chExit)
	}()
	// 定义标签
loop:
	for {
		select {
		case v, ok := <-chExit:
			if !ok {
				fmt.Println("close channel 1", v)
				// 跳出标签
				break loop
			}
			fmt.Println("ch1 val =", v)
		}
	}
	fmt.Println("exit testSelectFor")
}

select 超时控制

package main
import (
	"fmt"
	"time"
)
func main() {
	ch := make(chan int)
	quit := make(chan bool)
	//新开一个协程
	go func() {
		for {
			select {
			// case 1
			case num := <-ch:
				fmt.Println("num = ", num)
			// case 2
			case <-time.After(3 * time.Second):
				// 第一次for 会执行这里进入3秒倒计时，1秒时 num有数据可读，执行case 1，select结束，执行下一次for循环
				// 每次执行 time.After 把前面执行的倒计时又覆盖，又倒计时3秒
				// 等到第五次循环时，num已经没有数据写入了，倒计时3秒结束后，执行 case 2 代码，打印"超时"
				fmt.Println("超时")
				quit <- true

			}
			fmt.Println(111)
		}
	}()
	for i := 0; i < 5; i++ {
		ch <- i
		time.Sleep(time.Second)
	}
	// 前面for循环5秒就结束了，<-quit 读取数据，由于没有数据，所以这里会阻塞，直到3秒之后，quit <- true 才会继续往下走
	<-quit
	fmt.Println("程序结束")
}