Golang Channel通道使用简介

Golang Channel通道使用简介

一、channel简介

chan 是 Golang 中内置的数据类型,不像 Mutex 等需要引入,它是 first-class 类型,在 Go 的并发控制中起着相当重要的作用。chan 的思想来自 Tony Hoare 在 1978 年发表的论文 Communicating Sequential Processes, 它提出了一种并发的编程语言,用来描述并发系统中的互动模式,后来逐渐形成了 CSP 并发模式。CSP 模式中存在 Process/Channel 每个 Process 独立运行,多个 Process 之间通过 Channel 通信。

Go 并发控制的核心思想:

Don’t communicate by sharing memory, share memory by communicating. 
即不要通过共享内存来通信,而是要通过通信来共享内存,

前一句话对应传统利用 锁 等方式控制并发,后者就对应 CSP方式,go 中的 goroutine/chan 分别与 CSP 中的 Process/Channel 对应。

二、channel基础知识

基本分类

chan    // 既可以发送数据,又可以接收数据的 channel
chan<-  // 只能接收数据的 channel
<-chan  // 只能发送数据的 channel

channel 是管道,因此一个传输具体类型数据的 channel 声明方式如下:

var ch chan string      // 双向通道, 既可以往 ch 中写,也可以从 ch 中读 string 类型数据
var ch chan<- interface{} 或者 var ch = make(chan<- interface{}) // 只能往 ch 中发送 struct{} 类型数据
var ch <-chan int      或者 var ch make(<-chan int)        // 只能从 ch 中读取 int 数据

// 只读和只写一般用于数据通道,单独使用没有意义,比如:
func main() {
    c := make(chan int)
    go send(c)
    go recv(c)
    time.Sleep( * time.Second)
}
//只能向chan里写数据
func send(c chan<- int) {
    for i := ; i < ; i++ {
        c <- i
    }
}
//只能取channel中的数据
func recv(c <-chan int) {
    for i := range c {
        fmt.Println(i)
    }
}

channel 使用必须初始化,初始化是否指定长度可以分为

ch := make(chan string) // 无缓冲通道
ch := make(chan string, 2)// 有缓冲通道

三、基本使用

1) 发送数据

往 channel 中发送数据使用 “ch<-”,示例如下:

ch <- 10

这里的 ch 的类型是 chan int 或者 chan<- int

2) 接收数据

从 channel 中接收数据使用 “<-ch”,示例如下:

x := <-ch  // 把 ch 中接收到的一条数据赋值给 x
foo(<-ch) // 把 ch 中接收到的一条数据作为函数 foo 的参数
<-ch      // 丢弃一条从 ch 中接收到的数据

从 channel 中接收数据的时候,还可以接收两个值:

x, ok := <-ch

ok 是一个 bool 值,表示是否成功的从 channel 中接收到了数据。如果 ok 是 false,ch 已经被 close,且 ch 中没有缓存数据,那么 x 就是零值。所以,如果 x 是零值,有可能是接收到了零值,也有可能是空的且被 close 的 channel 产生的零值。

3) 其它操作

Go 的内建函数 close、cap、len 都可以操作 channel。close 可以关闭 channel,关闭之后的 channel 无法接收数据;cap 返回 channel 的容量;len 返回 channel 的长度。

发送和接收数据还可以作为 select 语句的 case clause,例如:

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

channel 还可以用于 for-range 语句中:

for v := range ch {
    fmt.Println(v)
}

或者是忽略读取的值,只是清空 channel:

for range ch {
}

四、踩坑注意

1) panic 错误

常见的会导致 panic 的三种场景如下:

  • close 为 nil 的 channel
  • close 已经 closed 的 channel
  • send 已经 close 的 channel
2) goroutine 泄露

无缓冲chan的使用,必须要求接收方和发送方都准备好,如果仅仅发送方准备好就发送信息,会导致chan阻塞,例如:

var ch = make(chan int)
ch <- -1
for {
	select {
        case res := <-ch:
		fmt.Println("收到信息",res)
	}
}

该示例中,对于无缓冲信道,在接收者未准备好之前,发送操作是阻塞的.,goroutine 无法退出,进而造成泄露。

解决方案1:让接收者提前做好准备,随时准备接受信息,推荐使用。

var ch = make(chan int)
go func() {
	for {
		select {
		case res := <-ch:
			fmt.Println("收到信息",res)
		}
	}
}()
ch <- -1 

解决方案2:使用有缓冲通道

var ch = make(chan int,1)
ch <- -1
fmt.Println("收到信息", <-ch)
3) 容量导致阻塞

每个缓冲信道,都有容量,当信道里的数据量等于信道的容量后,此时再往信道里发送数据,就失造成阻塞,必须等到有人从信道中消费数据后,程序才会往下进行。

func main() {
	ch1 := make(chan string, 1)

	ch1 <- "hello world"
	ch1 <- "hello China"// 超过容量,排队阻塞

	fmt.Println(<-ch1)
}
4) 持续读无写导致死锁

当程序一直在等待从信道里读取数据,而此时并没有人会往信道中写入数据。此时程序就会陷入死循环,造成死锁。

func main() {
	pipline := make(chan string)
	go func() {
		pipline <- "hello world"
		pipline <- "hello China"
	}()
	for data := range pipline{
		fmt.Println(data)
	}
}

解决:只要在发送完数据后,手动关闭信道,告诉 range 信道已经关闭,无需等待就行。

func main() {
	pipline := make(chan string)
	go func() {
		pipline <- "hello world"
		pipline <- "hello China"
		close(pipline)
	}()
	for data := range pipline{
		fmt.Println(data)
	}
}

你可能感兴趣的:(Golang基础简介,go)