协程线程进程的区别（大道如青天,协程来通信,Go lang1.18入门精炼教程，由白丁入鸿儒，Go lang通道channel的使用EP14）

众所周知  
    
    
    ，Go lang的作用域相对严格

     


     


     


，数据之间的通信往往要依靠参数的传递 




 




 




，但如果想在多个协程任务中间做数据通信  

   

   

   ，就需要通道（channel）的参与

     

     

     

，我们可以把数据封装成一个对象  




  




  




，然后把这个对象的指针传入某个通道变量中  


  


  


  ，另外一个协程从这个通道中读出变量的指针
     
     
     
，并处理其指向的内存对象    
    
    
。

通道的声明与创建

package main import "fmt" func main() { var a chan int if a == nil { fmt.Println("通道是空的, 不能使用
   




   




   




，需要先创建通道") a = make(chan int) fmt.Printf("数据类型是： %T", a) } }

这里注意 



 



 



 ，通道声明之后还需要进行创建   


     


     


    。

也可以通过海象操作符声明并创建：

package main import "fmt" func main() { a := make(chan int) fmt.Printf("数据类型是： %T", a) }

程序返回：

数据类型是： chan int%

如此                ，一个类型为整形的通道就创建好了



 




 




 


。

此外

    




    




    




，通道是引用数据类型：

package main import ( "fmt" ) func main() { ch1 := make(chan int) fmt.Printf("%T,%p\n", ch1, ch1) test1(ch1) } func test1(ch chan int) { fmt.Printf("%T,%p\n", ch, ch) }

程序返回：

chan int,0x1400010e060 chan int,0x1400010e060

可以看到














，在test1函数内和main函数内通道的地址是一样的                 ，所以他们指向的都是同一个通道   

   

   

。

通道的使用

通道创建之后

     



     



     



，即可以在协程之间充当桥梁：

package main import "fmt" func job(ch1 chan int) { ch1 <- 1 } func main() { ch1 := make(chan int) fmt.Println(ch1) go job(ch1) data := <-ch1 // 从ch1通道中读取数据 fmt.Println("data-->", data) fmt.Println("main    

     

     

   。




  




  




  

。over  


  


  


。     
     
     
  。




   




   




   
。
 



 



 



。") }

这里我们声明一个函数job














，把通道作为参数传递进去  
    
    
    ，注意这里参数类型除了声明通道本身以外

     


     


     


，还得声明通道具体的数据类型                。

随后在main函数中 




 




 




，可以理解为主协程  

   

   

   ，创建通道ch1

     

     

     

，执行开启协程任务job  




  




  




，在job函数内  


  


  


  ，往通道内传递数字1

接着
     
     
     
，主协程获取通道内由job协程传递的数据：

0x1400006a060 data--> 1 main 




    




    




    。
















。over               。  



     



     



     。
















。    
    
    
。

藉此
   




   




   




，就完成了数据的传递   


     


     


    。

这里需要注意通道的调用语法：

data := <- a // 读取通道 a <- data // 写入通道

同步阻塞

这里需要注意的是 



 



 



 ，通道无论是写入还是读取                ，都是同步阻塞机制



 




 




 


。即当有协程对通道进行操作的时候

    




    




    




，其他协程都处于“等待    
    
    
”状态














，说白了                 ，就是在“排队   


     


     


    ”

     



     



     



，在之前的一篇：并发与并行,同步和异步,Go lang1.18入门精炼教程














，由白丁入鸿儒  
    
    
    ，Go lang并发编程之GoroutineEP13

     


     


     


，我们要么通过sync.WaitGroup来阻塞主协程 




 




 




，或者通过time.Sleep(time.Second)方法来阻塞  

   

   

   ，就是怕主协程提前执行完

     

     

     

，早成子协程来不及执行   

   

   

。

而通道的出现  




  




  




，就间接帮我们实现了“阻塞



 




 




 


”主协程的目的    

     

     

   。

比如  


  


  


  ，多个协程任务操作一个变量：

package main import ( "fmt" ) func job1(number int, squareop chan int) { sum := 20 sum += number squareop <- sum } func job2(number int, cubeop chan int) { sum := 10 sum += number cubeop <- sum } func main() { number := 0 ch1 := make(chan int) ch2 := make(chan int) go job1(number, ch1) go job2(number, ch2) num1, num2 := <-ch1, <-ch2 fmt.Println("Final output", num1+num2) }

这里job1和job2两个协程任务同时异步执行
     
     
     
，操作number变量
   




   




   




，累加后往通道中写入 



 



 



 ，程序返回：

Final output 30

理论上                ，如果是并发执行

    




    




    




，返回值应该是20或者10














，但由于通道的存在                 ，造成协程任务阻塞

     



     



     



，变回了同步执行














，所以返回了30




  




  




  

。

同时  
    
    
    ，我们需要注意死锁问题

     


     


     


，如果一个协程任务在一个通道上发送数据 




 




 




，那么其他的协程任务应该接收数据  

   

   

   ，如果这种情况不发生

     

     

     

，那么程序将在运行时出现死锁  


  


  


。

换句话说  




  




  




，你发送了  


  


  


  ，就得有人接收
     
     
     
，只发不接
   




   




   




，或者只收不发 



 



 



 ，都会变成死锁     
     
     
  。

此外                ，协程任务可以通过close(ch)方法来关闭通道：

package main import ( "fmt" ) func job(ch1 chan int) { // 发送方：3条数据 for i := 0; i < 3; i++ { ch1 <- i //将i写入通道中 } close(ch1) //将ch1通道关闭了




   




   




   
。 } func main() { ch1 := make(chan int) go job(ch1) /* 子goroutine

    




    




    




，写出数据3个 每写一个














，阻塞一次                 ，主程序读取一次

     



     



     



，解除阻塞 主goroutine：循环读 每次读取一个














，堵塞一次  
    
    
    ，子程序

     


     


     


，写出一个 




 




 




，解除阻塞 发送发  

   

   

   ，关闭通道的--->接收方

     

     

     

，接收到的数据是该类型的零值  




  




  




，以及false */ //主程序中获取通道的数据 for { v, ok := <-ch1 //其他goroutine  


  


  


  ，显示的调用close方法关闭通道
 



 



 



。 if !ok { fmt.Println("已经读取了所有的数据
     
     
     
，", ok) break } fmt.Println("取出数据：", v, ok) } fmt.Println("main...over....") }

这里将0到2写入chl通道
   




   




   




，然后关闭通道                。主函数里有一个死循环 




    




    




    。类似while 



 



 



 ，它轮询通道是否在发送数据后                ，使用变量ok进行判断
















。如果ok是假的

    




    




    




，则意味着通道关闭














，因此循环结束                 ，否则将会继续进行无限轮询               。

select关键字

select 是 Go lang里面的一个流程控制结构

     



     



     



，和switch关键字差不多














，但是select会随机执行一个可运行的通道通信  
    
    
    ，如果没有通道通信可运行

     


     


     


，它将阻塞 




 




 




，直到有通道通信可运行：

package main import ( "fmt" "time" ) func job(ch1 chan int) { time.Sleep(2 * time.Second) ch1 <- 200 } func main() { ch1 := make(chan int) ch2 := make(chan int) go job(ch1) go job(ch2) select { case num1 := <-ch1: fmt.Println("ch1中取数据  



     



     



     。
















。", num1) case num2, ok := <-ch2: if ok { fmt.Println("ch2中取数据    
    
    
。   


     


     


    。", num2) } else { fmt.Println("ch2通道已经关闭



 




 




 


。   

   

   

。") } } }

这里select会随机选择一个可运行的通道通信逻辑  

   

   

   ，可能是ch1通道

     

     

     

，也有可能是ch2通道：

➜ mydemo git:(master) ✗ go run "/Users/liuyue/wodfan/work/mydemo/hello.go" ch1中取数据    

     

     

   。




  




  




  

。 200 ➜ mydemo git:(master) ✗ go run "/Users/liuyue/wodfan/work/mydemo/hello.go" ch1中取数据  


  


  


。     
     
     
  。 200 ➜ mydemo git:(master) ✗ go run "/Users/liuyue/wodfan/work/mydemo/hello.go" ch2中取数据




   




   




   
。
 



 



 



。 200 ➜ mydemo git:(master) ✗

结语

综上  




  




  




，Golang的通道其实就是将协程任务进行隔离  


  


  


  ，编写并发逻辑时
     
     
     
，关注通道即可
   




   




   




，说白了 



 



 



 ，Golang的通道就是Python多进程通信中的管道                ，Golang虽然没有显性的多进程调用

    




    




    




，但其协程调度底层就是多进程之间的通信














，因为只有多进程才可能利用CPU的多核资源                。