第十章 channel select 总结

前端之家收集整理的这篇文章主要介绍了第十章 channel select 总结前端之家小编觉得挺不错的,现在分享给大家,也给大家做个参考。

感觉channel在理解起来还有点费劲的,尤其是select的使用,既要可以读数据,又要可以写数据.

复习一下都学了哪些?然后在重点查一下select的资料


 

一. channel的定义. 

  • channel的读数据--两种方式
    package main
    
    import (
        "fmt"
        time"
    )
    
    func main() {
        a := make(chan int)
        // 定义一个goroutine不停的取数据
        go func() {
            for {
                 方式一: 使用ok来判断是否有数据,如果有数据则进行处理
                if aa,ok := <-a; ok {
                    fmt.Println(aa)
                }
            }
    
        }()
         加数据
        a <- 1
        a <- 23456
    
        time.Sleep(time.Second)
    }

    方式一: 使用ok来判断是否有数据,如果有数据则进行处理

     定义一个goroutine不停的取数据
        go func() {
             方式二: 从range中循环取数据,取出来则处理
            for aa := range a{
                fmt.Println(aa)
            }
    
        }()
        
    
        time.Sleep(time.Second)
    }

    方式二: 使用range来取数据

  • channel的写数据
  • channel的关闭数据
  • 带缓冲的channel
    a := make(chan int,3)

     

  • 函数是一等公民,channel也是一等公民,channel可以作为参数,返回值,数组等
  • 函数的可扩展性

二. select的使用

一个select语句用来选择哪个case中的发送或接收操作可以被立即执行。它类似于switch语句,但是它的case涉及到channel有关的I/O操作。
或者换一种说法,select就是用来监听和channel有关的IO操作,当 IO 操作发生时,触发相应的动作。
select的用法与switch非常类似,由select开始一个新的选择块,每个选择条件由case语句来描述。与switch语句可以选择任何可使用相等比较的条件相比,
select有比较多的限制,其中最大的一条限制就是每个case语句里必须是一个IO操作,确切的说,应该是一个面向channel的IO操作。

“ select”语句的执行分几个步骤进行:

@H_403_127@
  • For all the cases in the statement,the channel operands of receive operations and the channel and right-hand-side expressions of send statements are evaluated exactly once,in source order,upon entering the "select" statement.(所有channel表达式都会被求值、所有被发送的表达式都会被求值。求值顺序:自上而下、从左到右.
    结果是选择一个发送或接收的channel,无论选择哪一个case进行操作,表达式都会被执行。RecvStmt左侧短变量声明或赋值未被评估.)
  • If one or more of the communications can proceed,a single one that can proceed is chosen via a uniform pseudo-random selection. Otherwise,if there is a default case,that case is chosen. If there is no default case,the "select" statement blocks until at least one of the communications can proceed.(如果有一个或多个IO操作可以完成,则Go运行时系统会随机的选择一个执行,否则的话如果有default分支,则执行default分支语句,如果连default都没有,则select语句会一直阻塞,直到至少有一个IO操作可以进行.)
  • Unless the selected case is the default case,the respective communication operation is executed.(除非选择的情况是default case,否则将执行相应的操作。)
  • If the selected case is a RecvStmt with a short variable declaration or an assignment,the left-hand side expressions are evaluated and the received value (or values) are assigned.(如果所选case是带有简短变量声明或赋值的RecvStmt,则将评估左侧表达式并分配接收值(或多个值))
  • The statement list of the selected case is executed.(所选择的case被执行)
  • 备注:RecvStmt指的就是短变量. 例如: case n := <- a1,其中的n就是短变量

    示例1:select语句会一直等待,直到某个case里的IO操作可以进行

    
    )
    
    func main() {
        a1 := make(chan )
        a2 := make(chan )
    
         向管道a1中放数据
        go func() {
            time.Sleep(time.Second * )
            a1 <- 
        }()
    
         向管道a2中放数据
    )
            a2 <- 使用select从管道a1,a2中读数据
        select {
            case n := <- a1:
                fmt.Println(n)
            case n:= <- a2:
                fmt.Println(n)
        }
    
        time.Sleep(time.Second * 10)
    }

    一直等着,知道2s后a1通道有数据执行第一个case后打印,5s后a2通道有数据,select执行第二个case取出

    这个demo可以更好的说明,select一直在阻塞等待. 知道有符合条件的case执行. 

    for {
                 a1:
                    fmt.Println(n)
                    time.Sleep(time.Second)
                 a2:
                    fmt.Println(n)
                    time.Sleep(time.Second * )
                default:
                    fmt.Println(default)
                    time.Sleep(time.Second * )
            }
        }
    
        time.Sleep(time.Second * )
    }

     

    示例2:select语句的多个case同时满足条件,执行那个case是随机

    同样是上面的demo,两个时间都改为2s. 发现,运行结果,有时打印的是1,有时打印的是2

    func main() {
        a1 := make(chan     go func() {
            time.Sleep(time.Second * 2)
            a1 <-     go func() {
            time.Sleep(time.Second * 2)
            a2 <- )
    }

    示例3:所有channel表达式都会被求值、所有被发送的表达式都会被求值。求值顺序:自上而下、从左到右.

    package main
    
    import "
    
    var a1 = make(chan )
    var a2 = make(chan )
    
    var a = []chan  {a1,a2}
    
    var num = []int {1,1)">2,1)">3,1)">4,1)">5,1)">}
    func main() {
    
    
        go func(a chan ) {
            fmt.Println(<- a)
        }(a1)
    
        i:= 1
         {
        case getChan(i- getNumber(i,num) :
            fmt.Printf(把数字 %d 放在第 %d 通道里,i,i)
        case n := <- getChan(i-把数字从通道 %d 里取出来 %d \nint) chan {
        fmt.Println(chanreturn a[i]
    }
    
    func getNumber(i int)  {
        fmt.Println(num n[i]
    }

    结果

     

     

     在print之前,执行了两遍getChan,一遍getNumber

    示例4 break关键字结束select

    ch1 := make(chan )
        ch2 := make(chan )
    
        ch1 <- 
        ch2 <- 5
    
        case <- ch1:
    
            fmt.Println(ch1 selected.)
    
            break
    
            fmt.Println(ch1 selected after break ch2:
    
            fmt.Println(ch2 selected.)
            fmt.Println(ch2 selected without break)
        }

    很明显,ch1和ch2两个通道都可以读取到值,所以系统会随机选择一个case执行。我们发现选择执行ch1的case时,由于有break关键字只执行了一句

    ch1 selected.
    
    Process finished with exit code 0

    但是,当系统选择ch2的case时,打印结果为:

    ch2 selected.
    ch2 selected without 
    
    Process finished with exit code 0

    如此就显而易见,break关键字在select中的作用。

     

    示例5: 最后再来看一下我们的那个复杂的demo

    math/rand
    )
    
    func generator() chan {
        c := make(chan )
        i := 0
        go func() {
               {
                time.Sleep(time.Duration(rand.Intn(1500)) * time.Millisecond)
                i++
                c <- i
            }
    
        }()
         c
    }
    
    func createWorker(i {
        out := make(chan )
        go func() {
            for cc := range out {
                time.Sleep(time.Second*)
                fmt.Printf(管道a%d,value:%d\nreturn 
    }
    
    func main() {
        var a1 = generator()
        var a2 = generator()
    
        c := createWorker( {
    
            a1:
                c <- n
            a2:
                c <-/*default:
                fmt.Println("default")
                time.Sleep(time.Second)*/
            }
        }
    }

    这里定义了两个生产者管道,一个消费者管道,然后同时工作

    接下来想做的事是: 从生成数据的管道中取出数据,保存到消费管道中,消费数据.

    
    )
    
    func generator(num 
                fmt.Printf(管道编号: %d,i值:%d \n取数据--管道a%d,1)">var a1 = generator(var a2 = generator()
    
        c := createWorker()
        
        n := 0
    
        a1:
            a2:
            case c <- n:  从管道中取出的数据,放到消费者管道中
            }
        }
    }

    这样有一个问题,当消费数据速度慢时,会丢数据. 解决这个问题,使用一个数组来接收

    var values []int
        var activeValue int
             这里重新定义一个channel的原因是: 如果,values为空. 会将一个nil放入到c中. 
            后执行values = values[1:]会报下标越界. 所以定义activeChannel. 初始值时nil. 给一个nil管道放数据, 不会执行,会一直等待
            var activechannel chan if len(values) >   {
                activeValue = values[]
                activechannel = c
            }
            a1:
                values = append(values,n)
            a2:
                values =case activechannel <- activeValue: // 
                values = values[:]
            
            }
        }
    }
    将数组中的数据取出,放入channel的时候,可以成功. 但是汇报异常.
    这里重新定义一个channel的原因是: 如果,values为空. 会将一个nil放入到c中. 然后执行values = values[1:]会报下标越界. 所以定义activeChannel. 初始值时nil. 给一个nil管道放数据,不会执行,会一直等待

     

    接下来,写个定时器,让程序10秒后自动退出 

     定时发送任务. 返回的是一个时间的channel
        ta := time.After(time.Second * 10)
        //
                values = values[:]
            case <- ta: //每10秒从channel中取出数据,fmt.Println("bye")
                return
    
            
            }
        }
    }

    我们定义每超过800ms打印一次超时,这个和上一个定时的区别是: 他是两个case之间输出数据的时间>800. 而上一个的10秒钟是整个程序执行10秒钟

     

    )
    
        // 定时发送任务. 返回的是一个时间的channel
        ta := time.After(time.Second * 10)
        :]
            
            case <- time.After(time.Millisecond * 800):
                fmt.Println("timeout")
    
            
            }
        }
    }

    最后一个,定时打印每秒钟数组中积压的数据

     定时发送任务. 返回的是一个时间的channel
        ta := time.After(time.Second *  定时器,返回的也是一个管道. 每秒往管道中放一个数据
        tick := time.Tick(time.Second)
        case <- ta: 每10秒从channel中取出数据,
                fmt.Println(byereturn
            case <- time.After(time.Millisecond * 800):
                fmt.Println(timeout)
            case <- tick:
                fmt.Println("len:",len(values))
            
            }
        }
    }

     

     

     

     

     


    参考文献:

    1. https://www.jianshu.com/p/2a1146dc42c3

    2. https://blog.csdn.net/dwjpeng2/article/details/81700147

     

    猜你在找的Go相关文章