碼上快樂

相關內容    簡體    繁體

Go之go與channel組合使用

本文轉載自   查看原文   2015-01-23 11:34   6826    golang
1，等待一個事件
<- ch 將一直阻塞，直到ch被關閉 或者 ch中可以取出值 為止
所以到第17行之后會去執行go后面的func()匿名函數，在里面給ch賦值后（或者close（ch））后,才能繼續往后執行
  2. package main
  4. import(
  5. "fmt"
  6. )
  8. func main(){
  9. fmt.Println("Begin doing something!")
  10. ch := make(chan int)
  12. go func(){
  13. fmt.Println("Doing something…")
  14. ch <-22
  15. //close(ch)
  16. }()
  17. <-ch //此處將被阻塞，直到ch被關閉 或 有值可以取出
  18. fmt.Println("Done!")
  19. }
 
2,協同多個Goroutines
同上，close channel還可以用於協同多個Goroutines，比如下面這個例子，我們創建了100個Worker Goroutine，這些Goroutine在被創建出來后都阻塞在"<-start"上，直到我們在main goroutine中給出開工的信號："close(start)"，這些goroutines才開始真正的並發運行起來。
  1. package main
  3. import"fmt"
  5. func worker(start chan bool, index int){
  6. <-start // 從start中取出數據后，調用20行的case語句
  7. fmt.Println("This is Worker:", index)
  8. }
  10. func main(){
  11. start := make(chan bool)
  12. for i :=1; i <=10; i++{
  13. go worker(start, i)
  14. }
  15. //給start賦值10次，讓worker方法執行10次
  16. for i :=1; i <=10; i++{
  17. start <-true//給start賦值一次，便執行worker函數一次
  18. }
  19. v :=1
  20. //select 被一直阻塞直到start中數據被取出
  21. select{  //deadlock we expected
  22. case<-start:
  23. fmt.Print(v)
  24. v++
  25. }
  26. }
3,Select
  • select常與for一起使用
  1. for{
  2. select{
  3. case x :=<- somechan:
  4. // … 使用x進行一些操作
  6. case y, ok :=<- someOtherchan:
  7. // … 使用y進行一些操作，
  8. // 檢查ok值判斷someOtherchan是否已經關閉
  10. case outputChan <- z:
  11. // … z值被成功發送到Channel上時
  13. default:
  14. // … 上面case均無法通信時，執行此分支
  15. }
  16. }
  • 終結woker
 
下面是一個常見的終結sub worker goroutines的方法，
每個worker goroutine通過select監視一個die channel來及時獲取main goroutine的退出通知。
  1. package main
  3. import(
  4. "fmt"
  5. "time"
  6. )
  8. func worker(die chan bool, index int){
  9. fmt.Println("Begin: This is Worker:", index)
  10. for{
  11. select{
  12. //case xx：
  13. //做事的分支
  14. case<-die: //到這里就被阻塞，運行main中的close后輸出 done
  15. fmt.Println("Done: This is Worker:", index)
  16. return
  17. }
  18. }
  19. }
  21. func main(){
  22. die:= make(chan bool)
  24. for i :=1; i <=10; i++{
  25. go worker(die, i)
  26. }
  28. time.Sleep(time.Second*5)
  29. close(die)
  30. select{}//deadlock we expected
  31. }
 
  • 終結驗證
有時候終結一個worker后，main goroutine想確認worker routine是否真正退出了，可采用下面這種方法：
  1. package main
  3. import(
  4. "fmt"
  5. //"time"
  6. )
  8. func worker(die chan bool){
  9. fmt.Println("Begin: This is Worker")
  10. for{
  11. select{
  12. //case xx：
  13. //做事的分支
  14. case<-die://這里等待27行的賦值語句，如果沒有賦值，一直阻塞
  15. fmt.Println("Done: This is Worker")
  16. die<-true
  17. return
  18. }
  19. }
  20. }
  22. func main(){
  23. die:= make(chan bool)
  25. go worker(die)
  27. die<-true
  29. istrue :=<-die//這里等待16行的賦值，賦值完畢后程序繼續執行
  30. fmt.Println("Worker goroutine has been terminated", istrue)
  31. }
  • 關閉的Channel永遠不會阻塞
  1. package main
  3. import"fmt"
  5. func main(){
  6. cb := make(chan bool)
  7. close(cb)//當cb被關閉后，所有的取值操作將不會被阻塞
  8. x :=<-cb
  9. fmt.Printf("%#v\n", x)
  11. x, ok :=<-cb
  12. fmt.Printf("%#v %#v\n", x, ok)
  14. ci := make(chan int)
  15. close(ci)
  16. y :=<-ci //即使ci被關閉，照樣可以從ci中取數據，取得0
  17. fmt.Printf("%#v\n", y)
  19. cb <-true
  20. }

false

false false

0

panic: send on closed channel 

19行將報異常

可以看到在一個已經close的unbuffered channel上執行讀操作，回返回channel對應類型的零值，比如bool型channel返回false，int型channel返回0。但向close的channel寫則會觸發panic。不過無論讀寫都不會導致阻塞。

 

  • （5）關閉帶緩存的channel
 
  1. package main
  3. import"fmt"
  5. func main(){
  6. c := make(chan int,3)
  7. c <-15
  8. c <-34
  9. c <-65
  10. close(c)
  11. fmt.Printf("%d\n",<-c)//channel被關閉后，照樣可以從channel中取出數據，只是不能向其中寫數據
  12. fmt.Printf("%d\n",<-c)
  13. fmt.Printf("%d\n",<-c)
  14. fmt.Printf("%d\n",<-c)//當channel中數據全部被取出時，將輸出0
  16. c <-1
  17. }
15
34
65
0
panic: runtime error: send on closed channel 
16行將報異常
 
可以看出帶緩沖的channel略有不同。盡管已經close了，但我們依舊可以從中讀出關閉前寫入的3個值。第四次讀取時，則會返回該channel類型的零值。向這類channel寫入操作也會觸發panic。
 
  • range
Golang中的range常常和channel並肩作戰，它被用來從channel中讀取所有值。下面是一個簡單的實例：
  1. package main
  3. import"fmt"
  5. func generator(strings chan string){
  6. strings <-"Five hour's New York jet lag"
  7. strings <-"and Cayce Pollard wakes in Camden Town"
  8. strings <-"to the dire and ever-decreasing circles"
  9. strings <-"of disrupted circadian rhythm."
  10. close(strings)
  11. }
  13. func main(){
  14. strings := make(chan string)
  15. go generator(strings)
  16. for s := range strings {
  17. fmt.Printf("%s\n", s)//這里的s 相當於 <- strings，只有賦值之后才能讀取到，否則一直阻塞
  18. }
  19. fmt.Printf("\n")
  20. }
4. 隱藏狀態
沒有緩存 的chan默認為1個單位的緩存
  1. package main
  3. import"fmt"
  5. func newUniqueIDService()<-chan string{
  6. id := make(chan string)
  7. go func(){
  8. var counter int64 =0
  9. for{
  10. id <- fmt.Sprintf("%x", counter)
  11. counter +=1
  12. }
  13. }()
  14. return id
  15. }
  16. func main(){
  17. id := newUniqueIDService()
  18. for i :=0; i <10; i++{
  19. fmt.Println(<-id) //被阻塞，直到id被賦值
  20. }
  21. }
 
newUniqueIDService通過一個channel與main goroutine關聯，main goroutine無需知道uniqueid實現的細節以及當前狀態，只需通過channel獲得最新id即可。
 
 
5，select的default分支的實踐用法
  •        讀取時為空
  1. idle := make(chan []byte,5)//用一個帶緩沖的channel構造一個簡單的隊列
  3. select{
  4. case<-idle:
  5. //嘗試從idle隊列中讀取
  6. fmt.Println("讀取")
  7. default://隊列空，分配一個新的buffer
  8. fmt.Println("寫入")
  9. }
  •     寫入時已滿
  1. package main
  3. import(
  4. "fmt"
  5. )
  7. func main(){
  8. idle := make(chan []int,10)//用一個帶緩沖的channel構造一個簡單的隊列
  9. var b =[]int{2,1}
  10. select{
  11. case idle <- b://嘗試向隊列中插入一個buffer
  12. fmt.Println(idle)
  13. default://隊列滿？
  14. println("隊列滿")
  15. }
  16. }
6，Nil Channels
 
  • nil channels阻塞 : 對一個沒有初始化的channel進行讀寫操作都將發生阻塞
 
  1. package main
  3. func main(){
  4. var c chan int
  5. c <-1
  6. }
將發生阻塞
 
  • 循環輸出
  1. package main
  3. import"fmt"
  4. import"time"
  6. func main(){
  7. var c1, c2 chan int= make(chan int), make(chan int)
  8. go func(){
  9. time.Sleep(time.Second*5)
  10. c1 <-5
  11. close(c1)
  12. }()
  14. go func(){
  15. time.Sleep(time.Second*7)
  16. c2 <-7
  17. close(c2)
  18. }()
  20. for{
  21. select{
  22. case x :=<-c1://在等待5s后,把值取出，如果close（c1）那么，將一直輸出0
  23. fmt.Println(x)
  24. case x :=<-c2://在等待7s后，輸出c2的值並退出
  25. fmt.Println(x)
  26. return
  27. }
  28. }
  29. fmt.Println("over")
  30. }
輸出的結果是
5
0
0
0
...
7
 
改為交替輸出
  1. package main
  3. import"fmt"
  4. import"time"
  6. func main(){
  7. var c1, c2 chan int= make(chan int), make(chan int)
  8. go func(){
  9. time.Sleep(time.Second*5)
  10. c1 <-5
  11. close(c1)
  12. }()
  14. go func(){
  15. time.Sleep(time.Second*7)
  16. c2 <-7
  17. close(c2)
  18. }()
  20. for{
  21. select{
  22. case x, ok :=<-c1://如果c1未被關閉，則輸出x，如果x關閉，c1=nil
  23. if!ok {
  24. c1 =nil
  25. }else{
  26. fmt.Println(x)
  27. }
  28. case x, ok :=<-c2://如果c2未被關閉，則輸出x，如果x關閉，c2=nil
  29. if!ok {
  30. c2 =nil
  31. }else{
  32. fmt.Println(x)
  33. }
  34. }
  35. if c1 ==nil&& c2 ==nil{
  36. break//如果=nil那么推出
  37. }
  38. }
  39. fmt.Println("over")
  40. }
5
7
over
 
 
7.Timers
  • 超時機制Timeout
帶超時機制的select是常規的tip，下面是示例代碼，實現30s的超時select：
 
  1. func worker(start chan bool){
  2. timeout := time.After(30* time.Second)
  3. for{
  4. select{
  5. // … do some stuff
  6. case<- timeout:
  7. return
  8. }
  9. }
  10. }
 
  • 心跳HeartBeart
與timeout實現類似，下面是一個簡單的心跳select實現：
  2. func worker(start chan bool){
  3. heartbeat := time.Tick(30* time.Second)
  4. for{
  5. select{
  6. // … do some stuff
  7. case<- heartbeat:
  8. //… do heartbeat stuff
  9. }
  10. }
  11. }
 






免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。



猜您在找 使用go-channel實現消息隊列 go語言中帶緩沖區的channel的使用 go channel底層實現 channel的基本使用 Go基礎系列：channel入門 Go語言 之定義channel變量 go語言系列-從Goroutine到Channel golang channel 使用總結 GO語言練習：channel 緩沖機制 【Golang詳解】go語言中的channel
 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM