zoukankan      html  css  js  c++  java

  • Go之go与channel组合使用

    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 ", x)
    11. x, ok :=<-cb
    12. fmt.Printf("%#v %#v ", x, ok)
    14. ci := make(chan int)
    15. close(ci)
    16. y :=<-ci //即使ci被关闭，照样可以从ci中取数据，取得0
    17. fmt.Printf("%#v ", 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 ",<-c)//channel被关闭后，照样可以从channel中取出数据，只是不能向其中写数据
    12. fmt.Printf("%d ",<-c)
    13. fmt.Printf("%d ",<-c)
    14. fmt.Printf("%d ",<-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 ", s)//这里的s 相当于 <- strings，只有赋值之后才能读取到，否则一直阻塞
    18. }
    19. fmt.Printf(" ")
    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. }
     
  • 相关阅读:
    JavaScript 相等（==）与全等（===）操作符
    JavaScript 判断空对象、空数组的方法
    JavaScript中的深拷贝与浅拷贝
    JS trim去除字符串收尾指定字符
    Django+Markdown+Pygments 支持Markdown 实现代码高亮
    crontab 定时服务
    程序员如何修复婚姻的bug
    向Mysql 中插入汉字(Emoji)出现 Incorrect string value
    根据html页面id寻找对应的Js文件
    Django Pagination
  • 原文地址：https://www.cnblogs.com/anbylau2130/p/4243735.html
Copyright © 2011-2022 走看看