go channel 管道

Posted 看,未来

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了go channel 管道相关的知识,希望对你有一定的参考价值。

文章目录


概述

协程是并发编程的基础,而管道(channel)则是并发中协程之间沟通的桥梁,很多时候我们启动一个协程去执行完一个操作,执行操作之后我们需要返回结果,或者多个协程之间需要相互协作。


channel 基本使用

创建 channel

var ch0 chan int
var ch1 chan string
var ch2 chan map[string]string
type stu struct
var ch3 chan stu
var ch4 chan *stu

channel 方向 <-

ch <- v    // 发送值v到Channel ch中
v := <-ch  // 从Channel ch中接收数据,并将数据赋值给v

它包括三种类型的定义。可选的<-代表channel的方向。如果没有指定方向,那么Channel就是双向的,既可以接收数据,也可以发送数据。

chan T          // 可以接收和发送类型为 T 的数据
chan<- float64  // 只可以用来发送 float64 类型的数据
<-chan int      // 只可以用来接收 int 类型的数据

两个方向容易记混,这样,就默认我们是没有被显式写出的,那么 chan<- meme <-chan 就好记了吧。

在通讯(communication)开始前channel和expression必选先求值出来(evaluated),比如下面的(3+4)先计算出7然后再发送给channel。

c := make(chan int)
defer close(c)
go func()  c <- 3 + 4 ()
i := <-c
fmt.Println(i)

send被执行前(proceed)通讯(communication)一直被阻塞着。如前所言,无缓存的channel只有在receiver准备好后send才被执行。如果有缓存,并且缓存未满,则send会被执行往一个已经被close的channel中继续发送数据会导致run-time panic。往nil channel中发送数据会一致被阻塞着。

<-ch用来从channel ch中接收数据,这个表达式会一直被block,直到有数据可以接收。
从一个nil channel中接收数据会一直被block。

从一个被close的channel中接收数据不会被阻塞,而是立即返回,接收完已发送的数据后会返回元素类型的零值(zero value)。

如前所述,你可以使用一个额外的返回参数来检查channel是否关闭。

x, ok := <-ch
x, ok = <-ch
var x, ok = <-ch

如果OK 是false,表明接收的x是产生的零值,这个channel被关闭了或者为空。


make进行初始化

var ch0 chan int =make(chan int)
var ch1 chan int =make(chan int,10)

通过缓存的使用,可以尽量避免阻塞,提供应用的性能。
容量(capacity)代表Channel容纳的最多的元素的数量,代表Channel的缓存的大小。
如果没有设置容量,或者容量设置为0, 说明Channel没有缓存,只有sender和receiver都准备好了后它们的通讯(communication)才会发生(Blocking)。如果设置了缓存,就有可能不发生阻塞, 只有buffer满了后 send才会阻塞, 而只有缓存空了后receive才会阻塞。一个nil channel不会通信。
无缓存的与有缓存channel有着重大差别,那就是一个是同步的 一个是非同步的。

你可以在多个goroutine从/往 一个channel 中 receive/send 数据, 不必考虑额外的同步措施。


关闭 chan

这个要提一下,因为昨天写那个 “生成消费者” 就因为关闭出问题了。

使用内置函数close进行关闭,chan关闭之后,for range遍历chan中已经存在的元素后结束。
使用内置函数close进行关闭,chan关闭之后,没有使用for range的写法,需要使用,v, ok := <- ch进行判断chan是否关闭。

package main

import "fmt"

func main() 

	var ch chan int
	ch = make(chan int, 5)
	for i := 0; i < 5; i++ 
		ch <- i
	
	close(ch)
	for 
		var b int
		b, ok := <-ch
		if ok == false 
			fmt.Println("chan is close")
			break
		
		fmt.Println(b)
	

这个是很正常的。

如果将close(ch)注释掉,意思是不关闭管道,那么会出现dead lock死锁。因为存入管道5个数字,然后无限取数据,会出现死锁。

向 closed channel 发送数据引发 panic 错误,接收立即返回零值。而 nil channel, 无论收发都会被阻塞。

package main

func main() 
	ch := make(chan int, 1)
	close(ch)
	ch <- 2


range 遍历 chan

package main

import "fmt"

func main() 
	var ch chan int
	ch = make(chan int, 10)
	for i := 0; i < 10; i++ 
		ch <- i
	
	close(ch)
	for v := range ch 
		fmt.Println(v)
	

同样如果将close(ch)注释掉,意思是不关闭管道,那么会出现dead lock死锁。


内置函数len()、cap()

len 返回未被读取的缓冲元素数量,cap 返回缓冲区大小。

package main

import "fmt"

func main() 
	ch1 := make(chan int)
	ch2 := make(chan int, 3)
	ch2 <- 1
	fmt.Println(len(ch1), cap(ch1))
	fmt.Println(len(ch2), cap(ch2))


select

select 语句类似于 switch 语句,但是select会随机执行一个可运行的case。如果没有case可运行,它将阻塞,直到有case可运行。
select语句选择一组可能的send操作和receive操作去处理。

package main

import (
	"fmt"
)

func main() 
	ch1 := make(chan int, 1)
	ch1 <- 1
	ch2 := make(chan int, 1)
	ch2 <- 2
	select  //随机读数
	case k1 := <-ch1:
		fmt.Println(k1)
	case k2 := <-ch2:
		fmt.Println(k2)
	default:
		fmt.Println("chan")
	

timeout

select有很重要的一个应用就是超时处理。 因为上面我们提到,如果没有case需要处理,select语句就会一直阻塞着。这时候我们可能就需要一个超时操作,用来处理超时的情况。

package main

import (
	"fmt"
	"time"
)

func main() 
	c1 := make(chan string, 1)
	go func() 
		time.Sleep(time.Second * 2)
		c1 <- "result 1"
	()
	select 
	case res := <-c1:
		fmt.Println(res)
	case <-time.After(time.Second * 1):
		fmt.Println("timeout 1")
	


channel单向

可以将 channel 隐式转换为单向队列,只收或只发。
不能将单向 channel 转换为普通 channel。

package main

import (
	"fmt"
)

func main() 
	c := make(chan int, 3)
	var send chan<- int = c // send-only
	var recv <-chan int = c // receive-only
	send <- 5               // <-send               // Error: receive from send-only type chan<- int
	val, ok := <-recv
	if ok 
		fmt.Println(val)
	 // recv <- 2           // Error: send to receive-only type <-chan int

可以试着将 send 和 recv 的顺序反过来看看。


chan 作为 chan数

channel 是第一类对象,可传参 (内部实现为指针) 或者作为结构成员。

package main

import "fmt"

type Request struct 
	data []int
	ret  chan int


func NewRequest(data ...int) *Request 
	return &Requestdata, make(chan int, 1)


func Process(req *Request) 
	x := 0
	for _, i := range req.data 
		x += i
	
	req.ret <- x

func main() 
	req := NewRequest(10, 20, 30)
	Process(req)
	fmt.Println(<-req.ret)

以上是关于go channel 管道的主要内容,如果未能解决你的问题,请参考以下文章

7.2 什么是Go语言中的管道Channel

7.2 什么是Go语言中的管道Channel

Go语言的管道Channel用法

Go语言管道

go语言管道(channel)

go语言管道(channel)