Go之go與channel組合使用

時間 2019-11-09

標籤 channel 組合使用简体版

原文原文鏈接

1，等待一個事件

<- ch 將一直阻塞，直到ch被關閉或者 ch中能夠取出值爲止

因此到第17行以後會去執行go後面的func()匿名函數，在裏面給ch賦值後（或者close（ch））後,才能繼續日後執行

package main
import(
"fmt"
)
func main(){
fmt.Println("Begin doing something!")
ch := make(chan int)
go func(){
fmt.Println("Doing something…")
ch <-22
//close(ch)
}()
<-ch //此處將被阻塞，直到ch被關閉或有值能夠取出
fmt.Println("Done!")
}

2,協同多個Goroutines

同上，close channel還能夠用於協同多個Goroutines，好比下面這個例子，咱們建立了100個Worker Goroutine，這些Goroutine在被建立出來後都阻塞在"<-start"上，直到咱們在main goroutine中給出開工的信號："close(start)"，這些goroutines纔開始真正的併發運行起來。

package main
import"fmt"
func worker(start chan bool, index int){
<-start // 從start中取出數據後，調用20行的case語句
fmt.Println("This is Worker:", index)
}
func main(){
start := make(chan bool)
for i :=1; i <=10; i++{
go worker(start, i)
}
//給start賦值10次，讓worker方法執行10次
for i :=1; i <=10; i++{
start <-true//給start賦值一次，便執行worker函數一次
}
v :=1
//select 被一直阻塞直到start中數據被取出
select{ //deadlock we expected
case<-start:
fmt.Print(v)
v++
}
}

3,Select

select常與for一塊兒使用

for{
select{
case x :=<- somechan:
// … 使用x進行一些操做
case y, ok :=<- someOtherchan:
// … 使用y進行一些操做，
// 檢查ok值判斷someOtherchan是否已經關閉
case outputChan <- z:
// … z值被成功發送到Channel上時
default:
// … 上面case均沒法通訊時，執行此分支
}
}

終結woker

下面是一個常見的終結sub worker goroutines的方法，

每一個worker goroutine經過select監視一個die channel來及時獲取main goroutine的退出通知。

package main
import(
"fmt"
"time"
)
func worker(die chan bool, index int){
fmt.Println("Begin: This is Worker:", index)
for{
select{
//case xx：
//作事的分支
case<-die: //到這裏就被阻塞，運行main中的close後輸出 done
fmt.Println("Done: This is Worker:", index)
return
}
}
}
func main(){
die:= make(chan bool)
for i :=1; i <=10; i++{
go worker(die, i)
}
time.Sleep(time.Second*5)
close(die)
select{}//deadlock we expected
}

終結驗證

有時候終結一個worker後，main goroutine想確認worker routine是否真正退出了，可採用下面這種方法：

package main
import(
"fmt"
//"time"
)
func worker(die chan bool){
fmt.Println("Begin: This is Worker")
for{
select{
//case xx：
//作事的分支
case<-die://這裏等待27行的賦值語句，若是沒有賦值，一直阻塞
fmt.Println("Done: This is Worker")
die<-true
return
}
}
}
func main(){
die:= make(chan bool)
go worker(die)
die<-true
istrue :=<-die//這裏等待16行的賦值，賦值完畢後程序繼續執行
fmt.Println("Worker goroutine has been terminated", istrue)
}

關閉的Channel永遠不會阻塞

package main
import"fmt"
func main(){
cb := make(chan bool)
close(cb)//當cb被關閉後，全部的取值操做將不會被阻塞
x :=<-cb
fmt.Printf("%#v\n", x)
x, ok :=<-cb
fmt.Printf("%#v %#v\n", x, ok)
ci := make(chan int)
close(ci)
y :=<-ci //即便ci被關閉，照樣能夠從ci中取數據，取得0
fmt.Printf("%#v\n", y)
cb <-true
}

false緩存

false false併發

0函數

panic: send on closed channel spa

19行將報異常code

能夠看到在一個已經close的unbuffered channel上執行讀操做，回返回channel對應類型的零值，好比bool型channel返回false，int型channel返回0。但向close的channel寫則會觸發panic。不過不管讀寫都不會致使阻塞。隊列

（5）關閉帶緩存的channel

package main
import"fmt"
func main(){
c := make(chan int,3)
c <-15
c <-34
c <-65
close(c)
fmt.Printf("%d\n",<-c)//channel被關閉後，照樣能夠從channel中取出數據，只是不能向其中寫數據
fmt.Printf("%d\n",<-c)
fmt.Printf("%d\n",<-c)
fmt.Printf("%d\n",<-c)//當channel中數據所有被取出時，將輸出0
c <-1
}

15

34

65

0

panic: runtime error: send on closed channel

16行將報異常

能夠看出帶緩衝的channel略有不一樣。儘管已經close了，但咱們依舊能夠從中讀出關閉前寫入的3個值。第四次讀取時，則會返回該channel類型的零值。向這類channel寫入操做也會觸發panic。

range

Golang中的range經常和channel並肩做戰，它被用來從channel中讀取全部值。下面是一個簡單的實例：

package main
import"fmt"
func generator(strings chan string){
strings <-"Five hour's New York jet lag"
strings <-"and Cayce Pollard wakes in Camden Town"
strings <-"to the dire and ever-decreasing circles"
strings <-"of disrupted circadian rhythm."
close(strings)
}
func main(){
strings := make(chan string)
go generator(strings)
for s := range strings {
fmt.Printf("%s\n", s)//這裏的s 至關於 <- strings，只有賦值以後才能讀取到，不然一直阻塞
}
fmt.Printf("\n")
}

4. 隱藏狀態

沒有緩存的chan默認爲1個單位的緩存

package main
import"fmt"
func newUniqueIDService()<-chan string{
id := make(chan string)
go func(){
var counter int64 =0
for{
id <- fmt.Sprintf("%x", counter)
counter +=1
}
}()
return id
}
func main(){
id := newUniqueIDService()
for i :=0; i <10; i++{
fmt.Println(<-id) //被阻塞，直到id被賦值
}
}

newUniqueIDService經過一個channel與main goroutine關聯，main goroutine無需知道uniqueid實現的細節以及當前狀態，只需經過channel得到最新id便可。

5，select的default分支的實踐用法

讀取時爲空

idle := make(chan []byte,5)//用一個帶緩衝的channel構造一個簡單的隊列
select{
case<-idle:
//嘗試從idle隊列中讀取
fmt.Println("讀取")
default://隊列空，分配一個新的buffer
fmt.Println("寫入")
}

寫入時已滿

package main
import(
"fmt"
)
func main(){
idle := make(chan []int,10)//用一個帶緩衝的channel構造一個簡單的隊列
var b =[]int{2,1}
select{
case idle <- b://嘗試向隊列中插入一個buffer
fmt.Println(idle)
default://隊列滿？
println("隊列滿")
}
}

6，Nil Channels

nil channels阻塞 : 對一個沒有初始化的channel進行讀寫操做都將發生阻塞

package main
func main(){
var c chan int
c <-1
}

將發生阻塞

循環輸出

package main
import"fmt"
import"time"
func main(){
var c1, c2 chan int= make(chan int), make(chan int)
go func(){
time.Sleep(time.Second*5)
c1 <-5
close(c1)
}()
go func(){
time.Sleep(time.Second*7)
c2 <-7
close(c2)
}()
for{
select{
case x :=<-c1://在等待5s後,把值取出，若是close（c1）那麼，將一直輸出0
fmt.Println(x)
case x :=<-c2://在等待7s後，輸出c2的值並退出
fmt.Println(x)
return
}
}
fmt.Println("over")
}

輸出的結果是

5

0

0

0

...

7

改成交替輸出

5

7

over

7.Timers

超時機制Timeout

帶超時機制的select是常規的tip，下面是示例代碼，實現30s的超時select：

func worker(start chan bool){
timeout := time.After(30* time.Second)
for{
select{
// … do some stuff
case<- timeout:
return
}
}
}

心跳HeartBeart

與timeout實現相似，下面是一個簡單的心跳select實現：

func worker(start chan bool){
heartbeat := time.Tick(30* time.Second)
for{
select{
// … do some stuff
case<- heartbeat:
//… do heartbeat stuff
}
}
}

來自爲知筆記(Wiz)

相關文章

相關標籤/搜索

PHP 7 新特性

Docker命令大全

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。

最新文章

本站公眾號

歡迎關注本站公眾號,獲取更多信息

相關文章

>>更多相關文章<<