需求： 模拟两个协程，分别循环打印字母A和B。
分析： 要实现两个协程之间的交替协作，就必须用到channel通信机制，而channel正好是同步阻塞的。
半开方式
首先我们用一个channel变量来控制两个goroutine的交替打印：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
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，在条件控制下，交替打印奇偶数：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
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循环体的互斥问题。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
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，同样的原理：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
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结构一样，轮式交换角色。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
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的本质就是同步式的生产消费模式
补充：go 让N个协程交替打印1-100
今天遇到一道面试题，开启N个协程，并交替打印1-100如给定N=3则输出:
goroutine0: 0
goroutine1: 1
goroutine2: 2
goroutine0: 3
goroutine1: 4
面试时没答案，虽过后研究参考了一些网上方法，并记录下来，先上代码
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
|
func print() { chanNum := 3 // chan 数量 chanQueue := make([]chan int, chanNum) // 创建chan Slice var result = 0 // 值 exitChan := make(chan bool) // 退出标识 for i := 0; i < chanNum; i++ { // 创建chan chanQueue[i] = make(chan int) if i == chanNum-1 { // 给最后一个chan写一条数据，为了第一次输出从第1个chan输出 go func(i int) { chanQueue[i] <- 1 }(i) } } for i := 0; i < chanNum; i++ { var lastChan chan int // 上一个goroutine 结束才能输出 控制输出顺序 var curChan chan int // 当前阻塞输出的goroutine if i == 0 { lastChan = chanQueue[chanNum-1] } else { lastChan = chanQueue[i-1] } curChan = chanQueue[i] go func(i int, lastChan, curChan chan int) { for { if result > 100 { // 超过100就退出 exitChan <- true } // 一直阻塞到上一个输出完，控制顺序 <-lastChan fmt.Printf("thread%d: %d \n", i, result) result = result + 1 // 当前goroutine已输出 curChan <- 1 } }(i, lastChan, curChan) } <-exitChan fmt.Println("done")} |
1、第一个for循环创建chan
2、第二个for循环里的lastChan意思是，当前chan如果要打印数据，就必须得上一个chan打印完后才能打印。
这里假设N=2，chan索引为0,1，当索引1要输出,就阻塞到索引0的chan有数据为止，当自己打印完后往自己的chan中发送一个1,方便给依赖自己的chan 解除阻塞。
这里有个特殊的地方，当索引为0时，他的依赖索引chan就为chanQueue的长度-1，如果没有在创建Chan中的时候没有下面这一串代码就会造成死锁
|
1
2
3
4
5
6
|
if i == chanNum-1 { // 给最后一个chan写一条数据，为了第一次输出从第1个chan输出 go func(i int) { chanQueue[i] <- 1 }(i)} |
以上为个人经验，希望能给大家一个参考，也希望大家多多支持服务器之家。如有错误或未考虑完全的地方，望不吝赐教。
原文链接：https://blog.csdn.net/Gusand/article/details/99442113
