需求: 模拟两个协程,分别循环打印字母A和B。
分析: 要实现两个协程之间的交替协作,就必须用到channel通信机制
,而channel正好是同步阻塞的。
半开方式
- 首先我们用一个
channel变量
来控制两个goroutine的交替打印:
func main() {
exit := make(chan bool)
ch1 := make(chan int)
go func() {
for i := 1; i <= 10; i++ {
ch1 <- 0 //生产
fmt.Println("A",i)
}
exit <- true
}()
go func() {
for i := 1; i <= 10; i++ {
<-ch1 //消费
fmt.Println("B",i)
}
}()
<-exit
}
结果发现打印出了ABBAABBA...
的效果。
也就是我们控制了开始的次序,但没有控制结束的次序,发生了并发不安全的情况。
其实半开模式也可以用于某些场景下,如: 两个goroutine,在条件控制下,交替打印奇偶数:
func main() {
exit := make(chan bool)
ch1 := make(chan int)
go func() {
for i := 1; i <= 10; i++ {
ch1 <- 0
if i%2 == 0 {
fmt.Println("A", i)
}
}
exit <- true
}()
go func() {
for i := 1; i <= 10; i++ {
<-ch1
if i%2 == 1 {
fmt.Println("B", i)
}
}
}()
<-exit
}
封闭方式
- 接下来我们使用两个
channel变量
来模拟goroutine循环体的互斥问题
。
func main() {
exit := make(chan bool)
ch1, ch2 := make(chan bool), make(chan bool)
go func() {
for i := 1; i <= 10; i++ {
ch1 <- true
fmt.Println("A", i)
//在ch1和ch2之间是阻塞独占的
<-ch2
}
exit <- true
}()
go func() {
for i := 1; i <= 10; i++ {
<-ch1
fmt.Println("B", i)
ch2 <- true
}
}()
<-exit
}
我们在循环体首尾都使用了阻塞独占模式,两个chan交替释放控制权
,达到了安全的协程交互控制。
再看看下面的Demo,同样的原理:
func main(){
ch1 :=make(chan int)
ch2 :=make(chan string)
str :=[5]string{"a","b","c","d","e"}
go func() {
for i:=0;i<5;i++{
ch1<-i
fmt.Print(i+1)
<-ch2
}
}()
for _,v :=range str{
<-ch1
fmt.Print(v)
ch2<-v
}
}
缓冲模式
- 缓冲模式和封闭模式相似,只是封闭模式中,两个goroutine有明确的
首尾角色
。而缓冲模式的第一生产者交给了主协程,两个goroutine结构一样,轮式交换角色。
func main() {
exit := make(chan bool)
ch1, ch2 := make(chan bool,1), make(chan bool)
ch1 <- true //生产(选择一个启动项)
go func() {
for i := 1; i <= 10; i++ {
if ok := <-ch1; ok { //消费
fmt.Println("A", 2*i-1)
ch2 <- true //生产
}
}
}()
go func() {
defer func() { close(exit) }()
for i := 1; i <= 10; i++ {
if ok := <-ch2; ok { //消费
fmt.Println("B", 2*i)
ch1 <- true //生产
}
}
}()
<-exit
}
结论:Channel的本质就是
同步式的生产消费模式