Go语言学习笔记-通道

布满荆棘的人生 2022-01-12 04:03 367阅读 0赞

之前学习的Goroutine可以让我们便捷的进行并行编程，而**通道**则可以让我们方便的实现Goroutine之间的通信。

一个简单的通道使用示例：

> package main  
>   
> import (  
>     "fmt"  
>     "time"  
> )  
>   
> func slowFunc(c chan string) \{  
>     time.Sleep(time.Second \* 2)  
>     c <- "slowFunc() finished"  
> \}  
>   
> func main() \{  
>     c := make(chan string)  
>     go slowFunc(c)  
>   
>     msg := <-c  
>     fmt.Println(msg)  
> \}

这个Go程序中，我们定义了一个传送消息类型为string的通道，我们还开启了一个Goroutine，主函数执行到msg := <-c时会阻塞，直到收到一条从通道c发来的消息为止。

通道还具有缓冲的功能，下面的程序我们使用了一个缓冲区大小为2的通道：

> package main  
>   
> import (  
>     "fmt"  
>     "time"  
> )  
>   
> func receiver(c chan string) \{  
>     for msg := range c \{  
>         fmt.Println(msg)  
>     \}  
> \}  
>   
> func main() \{  
>     messages := make(chan string, 2)  
>     messages <- "hello"  
>     messages <- "world"  
>     close(messages)  
>     fmt.Println("Pushed two messages onto channel with no receivers")  
>     time.Sleep(time.Second \* 1)  
>     receiver(messages)  
> \}

运行该程序可知，即使调用close()关闭了通道后，已发送的消息依然保留在通道的缓冲中，只是无法再向通道发送消息。在receiver()函数中我们接收了通道中的所有消息并打印。

在实际项目中，我们很可能需要使用一个通道不断地传送数据，借助for语句我们可以实现这一点：

> package main  
>   
> import (  
>     "fmt"  
>     "time"  
> )  
>   
> func pinger(c chan string) \{  
>     t := time.NewTicker(1 \* time.Second)  
>     for \{  
>         c <- "ping"  
>         <-t.C  
>     \}  
> \}  
>   
> func main() \{  
>     messages := make(chan string)  
>     go pinger(messages)  
>     for \{  
>         msg := <-messages  
>         fmt.Println(msg)  
>     \}  
> \}

此例为不断地通过通道发送和接收数据。

除此之外，还有select语句，它类似于switch语句，会执行最先收到消息的通道的case语句

> package main  
>   
> import (  
>     "fmt"  
>     "time"  
> )  
>   
> func ping1(c chan string) \{  
>     time.Sleep(time.Second \* 1)  
>     c <- "ping on channel1"  
> \}  
>   
> func ping2(c chan string) \{  
>     time.Sleep(time.Second \* 2)  
>     c <- "ping on channel2"  
> \}  
>   
> func main() \{  
>     channel1 := make(chan string)  
>     channel2 := make(chan string)  
>   
>     go ping1(channel1)  
>     go ping2(channel2)  
>   
>     select \{  
>     case msg1 := <-channel1:  
>         fmt.Println("received", msg1)  
>     case msg2 := <-channel2:  
>         fmt.Println("received", msg2)  
>     \}  
> \}

从此程序可知，接收到一条消息后，select语句将不再阻塞。

如果不想select语句无限的阻塞，可以专门使用一个通道来接收退出消息，称之为退出通道，如下：

> package main  
>   
> import (  
>     "fmt"  
>     "time"  
> )  
>   
> func sender(c chan string) \{  
>     for \{  
>         c <- "I'm sending a message"  
>         time.Sleep(time.Second \* 1)  
>     \}  
> \}  
>   
> func stopFunc(c chan bool) \{  
>     time.Sleep(time.Second \* 2)  
>     fmt.Println("Time's up!")  
>     c <- true  
> \}  
>   
> func main() \{  
>     messages := make(chan string)  
>     stop := make(chan bool)  
>     go sender(messages)  
>     go stopFunc(stop)  
>   
>     for \{  
>         select \{  
>         case <- stop:  
>             return  
>         case msg:= <- messages:  
>             fmt.Println(msg)  
>         \}  
>     \}  
> \}

转载于:https://www.cnblogs.com/paralysis/p/10669747.html