概述
上篇博文说明了 go 语言的并发机制 ----- go 协程(goroutine),本文将介绍并发通信机制;
goroutine运行在相同的地址空间,因此访问共享内存必须做好同步。goroutine 奉行通过通信来共享内存,而不是通过共享内存来进行通信
引用类型 channel 是CSP 模式的具体体现,用户多个 goroutine 通讯;其内部实现了同步,确保并发安全。
channel 默认为同步模式,需要发送和接收配对。否则会被阻塞,知道另一方准备好后被唤醒。
channel
和map 类似, channel也是一个对应 make 创建的底层数据结构的引用
当复制一个channel 或用户函数参数传递时,我们只是拷贝了一个channel 引用
定义一个channel时,也需要定义发送到channel 的值的类型,channel 可以使用内置的make函数来创建
make(chan Type)
make(chan Type, capacity)
当capacity = 0 时,channel是无缓冲阻塞读写的, 当 capacity > 0时, channel有缓冲非阻塞的,直到写满 capacity个元素才阻塞写入
channel 通过操作符 <- 来接收和发送数据,发送和接收数据语法:
channel <- value //发送value 到 channel
<-channel //接收并将其丢弃
x := <-channel //从channel中接收数据,并赋值给x
x, ok := <-channel //从channel中接收数据,并赋值给x,同时检查通道是否已关闭或者是否为空
默认情况下,channel 接收和发送数据都是阻塞的,除非另一端已经准备好,这样就使得goroutine 同步变得更加简单,而不需要显示的lock
channel 简单示例:
package main
import (
"fmt"
"time"
)
func main() {
// //创建一个channel ch
ch := make(chan string)
go func() {
defer fmt.Println("子协程调用完毕...")
for i := 0; i < 2; i++ {
fmt.Println("i = ", i)
time.Sleep(time.Second)
}
fmt.Println("我是子协程,已工作完毕")
ch <- "我是子协程,已工作完毕"
}()
// <-ch 没有数据前, 会一直阻塞
str := <-ch
fmt.Println("str = ", str)
}
执行结果如下:
------------------------------------------------------------
~/work_space/go_works/src/admin/channel » go run channelOps.go ryanxu@iterm
i = 0
i = 1
我是子协程,已工作完毕
子协程调用完毕...
str = 我是子协程,已工作完毕
无缓存 channel
无缓冲的Channel创建格式
make(chan Type)
make(chan Type, 0)
两种方式等价;
如果没有指定缓冲区容量,那么该通道就是同步的,因此会阻塞到发送者准备好发送和接收者准备好接收
package main
import (
"fmt"
"time"
)
func main() {
//创建一个无缓存的channel
ch := make(chan int, 0)
//len(ch) 缓冲去剩余数据个数, cap(ch) 缓冲区大小
fmt.Printf("len(ch) = %d \t, cap(ch) = %d \n", len(ch), cap(ch))
//新建一个协程
go func() {
for i := 0; i < 3; i++ {
fmt.Println("子协程: i = ", i)
ch <- i //往ch 中 写数据
}
}()
time.Sleep(2 * time.Second)
for i := 0; i < 3; i++ {
num := <-ch
fmt.Println("num = ", num)
}
}
执行结果如下:
------------------------------------------------------------
~/work_space/go_works/src/admin/channel » go run channelOps.go ryanxu@iterm
len(ch) = 0 , cap(ch) = 0
子协程: i = 0
num = 0
子协程: i = 1
子协程: i = 2
num = 1
num = 2
------------------------------------------------------------
~/work_space/go_works/src/admin/channel »
有缓存 Channel
有缓冲通道(buffered channel)是一种再被接收前能存储一个或多个值的通道
这种类型的通道并不强制要求goroutine 之间必须同时完成发送和接收。通道会阻塞发送和接收动作的条件也会不同。只有在通道中没有要接收的值时,接收动作才会阻塞。只有在通道没有可用缓冲区容纳被发送的值时,发送动作才会阻塞。
这导致有缓冲通道和无缓冲通道之间的一个很大的不同, 无缓冲的通道保证进行发送和接收的goroutine 会在同一时间进行数据交换,有缓冲的通道没有这种保证。
有缓冲的Channel创建格式
make(chan Type, capacity) //capacity > 0
如果给定了一个缓冲区容量,通道就是异步的,只要缓冲区有未使用空间用于发送数据,或还包含可以接受的数据,那么其通信就会无阻塞低进行
package main
import (
"fmt"
"time"
)
func main() {
//创建一个有缓冲的channel
ch := make(chan int, 3)
fmt.Printf("len(ch) = %d \t, cap(ch) = %d \n", len(ch), cap(ch))
//新建一个协程
go func() {
for i := 0; i < 10; i++ {
ch <- i //往ch 中 写数据
fmt.Printf("子协程[%d]:len(ch) = %d \t, cap(ch) = %d \n", i, len(ch), cap(ch))
}
}()
time.Sleep(2 * time.Second)
for i := 0; i < 10; i++ {
num := <-ch
fmt.Println("num = ", num)
}
}
执行结果如下:
~/work_space/go_works/src/admin/channel » go run channelOps.go ryanxu@iterm
len(ch) = 0 , cap(ch) = 3
子协程[0]:len(ch) = 1 , cap(ch) = 3
子协程[1]:len(ch) = 2 , cap(ch) = 3
子协程[2]:len(ch) = 3 , cap(ch) = 3
num = 0
子协程[3]:len(ch) = 3 , cap(ch) = 3
子协程[4]:len(ch) = 3 , cap(ch) = 3
num = 1
num = 2
num = 3
子协程[5]:len(ch) = 2 , cap(ch) = 3
子协程[6]:len(ch) = 2 , cap(ch) = 3
子协程[7]:len(ch) = 3 , cap(ch) = 3
num = 4
num = 5
num = 6
num = 7
num = 8
子协程[8]:len(ch) = 0 , cap(ch) = 3
子协程[9]:len(ch) = 0 , cap(ch) = 3
num = 9
------------------------------------------------------
关闭channel
close(channel_name) //channel_name 指创建的通道对象
- channel 不想文件一样需要经常去关闭,只有当确定没有任何数据需要发送了,或者想显示结束range 循环之类的,才去关闭channel
- 关闭 Channel后, 无法想channel 再发送数据(引发panic错误后导致接收立即返回零值)
- 关闭Channel 后,可以继续想channel 接收数据
- 对于nil channel, 无论收发都会被阻塞
package main
import "fmt"
func main() {
//创建一个无缓存channel
ch := make(chan int, 0)
go func() {
for i := 0; i < 5; i++ {
ch <- i //给通道写数据
}
//如果不需要再写数据的时候, 则关闭channel
close(ch)
}()
for {
if num, ok := <-ch; ok == true {
fmt.Println("num = ", num)
} else { //管道关闭
break
}
}
}
执行结果如下:
~/work_space/go_works/src/admin/channel » go run channelOps.go ryanxu@iterm
num = 0
num = 1
num = 2
num = 3
num = 4
----------------------------------------------
单向通道
单向通道是指, 定义一个通道可以指定其为只读 或者 只写类型; 默认的 是 双向通道,即:可读可写;
代码示例如下:
package main
import (
"fmt"
)
func main() {
//定义一个双向通道 ch
ch := make(chan int)
//生产者,生成数字,写入 ch
go producer(ch) // channel 作为参数是引用传递
//消费者,获取数字,从ch 接收
consumer(ch)
}
//单向,只写channel;
func producer(out chan<- int) {
for i := 0; i < 10; i++ {
out <- i * i
}
//关闭通道
close(out)
}
//单向,只读channel
func consumer(in <-chan int) {
//循环变量 通道in
for num := range in {
fmt.Println("num = ", num)
}
}
程序运行结果:
~/work_space/go_works/src/admin/channel » go run channelOps.go ryanxu@iterm
num = 0
num = 1
num = 2
num = 3
num = 4
------------------------------------------------------------