Golang的select多路复用及channel使用操作_Golang

Golang的select多路复用及channel使用操作

2021-03-14 01:00piperck Golang

这篇文章主要介绍了Golang的select多路复用及channel使用操作，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧

看到有个例子实现了一个类似于核弹发射装置，在发射之前还是需要随时能输入终止发射。

这里就可以用到cahnnel 配合select 实现多路复用。

select的写法用法有点像switch。但是和switch不同的是，select的一个case代表一个通信操作(在某个channel上进行发送或者接收)并且会包含一些语句组成的一个语句块。现在让我们来实现一下这个核弹发射器

									package main

									import (

									 "fmt"

									 "time"

									 "os"

									)

									func launch() {

									 fmt.Println("nuclear launch detected")

									}

									func commencingCountDown(canLunch chan int) {

									 c := time.Tick(1 * time.Second)

									 for countDown := 20; countDown > 0; countDown-- {

									  fmt.Println(countDown)

									  <- c

									 }

									 canLunch <- -1

									}

									func isAbort(abort chan int) {

									 os.Stdin.Read(make([]byte, 1))

									 abort <- -1

									}

									func main() {

									 fmt.Println("Commencing coutdown")

									 abort := make(chan int)

									 canLunch := make(chan int)

									 go isAbort(abort)

									 go commencingCountDown(canLunch)

									 select {

									 case <- canLunch:

									 case <- abort:

									  fmt.Println("Launch aborted!")

									  return

									 }

									 launch()

									}

首先打印了一个commencing countdown开始进行倒数计时。

申明一个int类型的 channel变量abort 用来做取消时候传递给select的消息信号量这个后面会介绍到。

申明一个int类型的 channel变量canLunch 用来做倒计时结束可以发射的信号量。只有当倒数结束，且canLunch有值后才能进行发射。

用一个goroutine开启一个用于监听是否有停止发射信号的函数isAbort并且把申明好的channel变量传入。

isAbort就干一件事情，监听是否有标准输入输入，如果有输入我们默认是下达了发射停止的信号需要向abort channel里面发送一个信号。这里我们会发射一个-1

用一个goroutine开启一个用于倒数计时的函数commencingCountDown负责开始倒计时，这里重新申明了一个 TICK channel 每一秒倒数计时一下。并且在倒数计时完成之后向canLunch channel发送信号。

然后开始执行select，select在没有就绪的channel的时候会阻塞或者执行指定的defualt，这里我没有写default所以他会阻塞监听两个信号，一个是canLunch，一个是停止发送。只要收到任何一个信号后，执行该信号后面的内容

最后运行Lunch函数。

其实把思路理清楚，以并发的思考方式去思考这类问题感觉还是不会太乱。多加练习应该会变好。下面的文章应该会开始逐步开始从服务器和连接开始，实现一个im系统。或者添加更多的实践。

补充：golang 使用select完成超时

我就废话不多说了，大家还是直接看代码吧~

									timeout := make(chan bool, 1)

									go func() {

									 time.Sleep(1e9)

									 timeout <- true

									} ()

									select {

									 case <- ch:

									  //从ch中读取数据

									 case <-timeout:

									  //ch一直没有数据写入，超时触发timeout

									}

									func main() {

									 var a chan string

									 a =make(chan string)

									 go sendDataTo(a)

									 go timing()

									 getAchan(10*time.Second,a) 

									}

									func sendDataTo(a chan string) {

									 for {

									   a <- "我是a通道的数据"

									  time.Sleep(1e9 *3)

									 }

									}

									//在一定时间内接收不到a的数据则超时

									func getAchan(timeout time.Duration, a chan string) {

									 var after <-chan time.Time

									 loop:

									 after = time.After(timeout)

									 for{

									  fmt.Println("等待a中的数据，10秒后没有数据则超时")

									  select {

									  case x :=<- a:

									   fmt.Println(x)

									   goto loop

									  case <-after:

									   fmt.Println("timeout.")

									   return

									  }

									 }

									}

									func timing() {

									 //定时器，10秒钟执行一次

									 ticker := time.NewTicker(10 * time.Second)

									 for {

									  time := <-ticker.C

									  fmt.Println("定时器====>",time.String())

									 }

									}