GO利用channel协调协程的实现

尤芙蓉

目录

• 前言
  
• 使用
  
• 实现生产者消费者模式
  
• 实战面试题: 「交替打印数字和字母」
  
  
  
  • 题目
    
  • 解题思路
    
  
  
• 结尾
  

前言

go 当中的并发编程是通过goroutine来实现的，利用channel（管道）可以在协程之间传递数据，实现协程的协调与同步。

使用

新建一个管道，使用make channel 来构建

1. // 构建一个缓存长度为8 的管道
   
2. ch := make(chan int ,8)
   
3. // 写入
   
4. ch <- 10
   
5. // 取出
   
6. number := <-ch
   
7. // 关闭
   
8. close(ch)

复制代码

注意⚠️： 取数据的时候，如果没得取，会阻塞代码的执行，如果一直没有取到，那就是死锁

实现生产者消费者模式

两个生产者者协程和一个消费者协程
使用waitGroup

1. func main() {  
   
2.     ch := make(chan int, 100)  
   
3.     wg := sync.WaitGroup{}  
   
4.     wg.Add(2)  
   
5.     // 生产者
   
6.     go func() {  
   
7.         defer wg.Done()  
   
8.         // 写入数据  
   
9.         for i := 0; i < 10; i++ {  
   
10.             ch <- i  
    
11.         }  
    
12.     }()  
    
13.     // 生产者
    
14.     go func() {  
    
15.         defer wg.Done()  
    
16.         // 写入数据  
    
17.         for i := 0; i < 10; i++ {  
    
18.             ch <- i  
    
19.         }  
    
20.     }()  
    
21.     wg2 := sync.WaitGroup{}  
    
22.     wg2.Add(1)  
    
23.     // 消费者
    
24.     go func() {  
    
25.         sum := 0  
    
26.         fmt.Printf("sum %d \n", sum)  
    
27.         for {  
    
28.             // 这里会等待  
    
29.             temp, ok := <-ch  
    
30.             // close 并且 管道为空，ok = false  
    
31.             if !ok {    
    
32.                 break  
    
33.             } else {  
    
34.                 sum += temp  
    
35.             }  
    
36.         }  
    
37.         fmt.Printf("sum %d \n", sum)  
    
38.         wg2.Done()  
    
39.     }()  
    
40.     // 等待俩生产者结束  
    
41.     wg.Wait()  
    
42.     // 生产数据之后，消费者也并行读完了，此时可以关闭 管道 来 跳出for循环了 
    
43.     close(ch)  
    
44.     // 等待消费者协程结束  
    
45.     wg2.Wait()  
    
46. }

复制代码

使用管道则将wg2相关的代码改掉

1. func main() {  
   
2.     //... 
   
3.     //...
   
4.     ch2 := make(chan struct{}, 0)  
   
5.     go func() {  
   
6.         sum := 0  
   
7.         fmt.Printf("sum %d \n", sum)  
   
8.         for {  
   
9.             // 这里会等待  
   
10.             temp, ok := <- ch  
    
11.             // close 并且 管道为空，ok = false  
    
12.             if !ok {  
    
13.                 break  
    
14.             } else {  
    
15.                 sum += temp  
    
16.             }  
    
17.         }  
    
18.         fmt.Printf("sum %d \n", sum)  
    
19.         ch2 <- struct{}{}  
    
20.     }()  
    
21.     // 等待俩生产者结束  
    
22.     wg.Wait()  
    
23.     // 关闭管道
    
24.     close(ch)  
    
25.     // 等待消费者协程结束  
    
26.     <-ch2
    
27. }

复制代码

实战面试题: 「交替打印数字和字母」


题目

使用两个 goroutine 交替打印序列，一个 goroutine 打印数字， 另外一个 goroutine 打印字母， 最终效果如下：

1. 12AB34CD56EF78GH910IJ1112KL1314MN1516OP1718QR1920ST2122UV2324WX2526YZ2728

复制代码

解题思路

利用channel的 阻塞 来协调线程，达到线程交叉执行的效果。
代码

1. func main() {  
   
2.     letter, number := make(chan bool), make(chan bool)  
   
3.     wait := sync.WaitGroup{}  
   
4.     go func() {  
   
5.         i := 1  
   
6.         for {  
   
7.             if <-number {  
   
8.                 fmt.Print(i)  
   
9.                 i++  
   
10.                 fmt.Print(i)  
    
11.                 i++  
    
12.                 letter <- true  
    
13.             }  
    
14.         }  
    
15.     }()  
    
16.     wait.Add(1)  
    
17.     go func() {  
    
18.         // 获得ASCII码  
    
19.         i := 'A'  
    
20.         for {  
    
21.             if <-letter {  
    
22.                 // 当前已经超过Z时，无需再打印
    
23.                 if i > 'Z' {  
    
24.                     // 停止等待，并且跳出循环
    
25.                     wait.Done()  
    
26.                     break  
    
27.                 }  
    
28.                 // 将ASCII码强转成字母输出  
    
29.                 fmt.Print(string(i))  
    
30.                 i++  
    
31.                 fmt.Print(string(i))  
    
32.                 i++  
    
33.                 number <- true  
    
34.             }  
    
35.         }  
    
36.     }()  
    
37.     // 放行数字打印的阻塞
    
38.     number <- true  
    
39.     // 等待关闭主线程
    
40.     wait.Wait()  
    
41. }

复制代码

其实完全也可以将waitGroup换成管道

1. func main() {  
   
2.     letter, number := make(chan bool), make(chan bool)  
   
3.     // 再定义一个管道来等待，替代waitGroup的作用
   
4.     wait := make(chan bool)
   
5.     // 打印数字
   
6.     go func() {  
   
7.         i := 1  
   
8.         for {  
   
9.             if <-number {  
   
10.                 fmt.Print(i)  
    
11.                 i++  
    
12.                 fmt.Print(i)  
    
13.                 i++  
    
14.                 letter <- true  
    
15.             }  
    
16.         }  
    
17.     }()  
    
18.     // 打印字母
    
19.     go func() {  
    
20.         // 获得ASCII码  
    
21.         i := 'A'  
    
22.         for {  
    
23.             if <-letter {  
    
24.                 if i > 'Z' {  
    
25.                     wait <- true  
    
26.                     break  
    
27.                 }  
    
28.                 // 将ASCII码强转成字母输出  
    
29.                 fmt.Print(string(i))  
    
30.                 i++  
    
31.                 fmt.Print(string(i))  
    
32.                 i++  
    
33.                 number <- true  
    
34.             }  
    
35.         }  
    
36.     }()  
    
37.     number <- true  
    
38.     // 等待管道取值
    
39.     <- wait
    
40. }

复制代码

结尾

到此这篇关于GO利用channel协调协程的实现的文章就介绍到这了,更多相关GO  channel协调协程内容请搜索晓枫资讯以前的文章或继续浏览下面的相关文章希望大家以后多多支持晓枫资讯！

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

紫色风玲

感谢楼主分享。

隆善芳

感谢楼主，顶。