3种优雅的Go channel用法

来源：互联网发布：光环大数据可视化编辑：程序博客网时间：2024/06/15 10:47

写Go的人应该都听过Rob Pike的这句话
Do not communicate by sharing memory; instead, share memory by communicating.
相信很多朋友和我一样，在实际应用中总感觉不到好处，为了用channel而用。但以我的切身体会来说，这是写代码时碰到的场景不复杂、对channel不熟悉导致的，所以希望这篇文章能给大家带来点新思路，对Golang优雅的channel有更深的认识：）

Fan In/Out

数据的输出有时候需要做扇出／入（Fan In／Out），但是在函数中调用常常得修改接口，而且上下游对于数据的依赖程度非常高，所以一般使用通过channel进行Fan In／Out，这样就可以轻易实现类似于shell里的管道。

func fanIn(input1, input2 <-chan string) <-chan string {   c := make(chan string)   go func() {       for {           select {           case s := <-input1:  c <- s           case s := <-input2:  c <- s           }       }   }()   return c}

同步Goroutine

两个goroutine之间同步状态，例如A goroutine需要让B goroutine退出，一般做法如下：

func main() {   g = make(chan int)   quit = make(chan bool)   go B()   for i := 0; i < 3; i++ {       g <- i   }   quit <- true // 没办法等待B的退出只能Sleep   fmt.Println("Main quit")}func B() {   for {       select {       case i := <-g:           fmt.Println(i + 1)       case <-quit:           fmt.Println("B quit")           return       }   }}/*Output:123Main quit*/

可是了main函数没办法等待B合适地退出，所以B quit 没办法打印，程序直接退出了。然而，chan是Go里的第一对象，所以可以把chan传入chan中，所以上面的代码可以把quit 定义为chan chan bool，以此控制两个goroutine的同步

func main() {   g = make(chan int)   quit = make(chan chan bool)   go B()   for i := 0; i < 5; i++ {       g <- i   }   wait := make(chan bool)   quit <- wait   <-wait //这样就可以等待B的退出了   fmt.Println("Main Quit")}func B() {   for {       select {       case i := <-g:           fmt.Println(i + 1)       case c := <-quit:           c <- true           fmt.Println("B Quit")           return       }   }}/* Output123B QuitMain Quit*/

分布式递归调用

在现实生活中，如果你要找美国总统聊天，你会怎么做？第一步打电话给在美国的朋友，然后他们也会发动自己的关系网，再找可能认识美国总统的人，以此类推，直到找到为止。这在Kadmelia分布式系统中也是一样的，如果需要获取目标ID信息，那么就不停地查询，被查询节点就算没有相关信息，也会返回它觉得最近节点，直到找到ID或者等待超时。好了，这个要用Go来实现怎么做呢？

func recursiveCall(ctx context.Context, id []byte, initialNodes []*node){seen := map[string]*node{} //已见过的节点记录request := make(chan *node, 3) //设置请求节点channel        // 输入初始节点go func() {for _, n := range initialNodes {request <- n}}()OUT:for {               //循环直到找到数据if data != nil {    return}                // 在新的请求，超时和上层取消请求中selectselect {case n := <-request:go func() {                                // 发送新的请求response := s.sendQuery(ctx, n, MethodFindValue, id)select {case <-ctx.Done():case msg :=<-response:                                    seen[responseToNode(response)] = n //更新已见过的节点信息                                                // 加载新的节点for _, rn := range LoadNodeInfoFromByte(msg[PayLoadStart:]) {mu.Lock()_, ok := seen[rn.HexID()]mu.Unlock()                                                        // 见过了，跳过这个节点if ok {  continue}AddNode(rn)                                                        // 将新的节点送入channelrequest <- rn}}}}()case <-time.After(500 * time.Millisecond):break OUT // break至外层，否则仅仅是跳至loop外        case <-ctx.Done():break OUT}}return}

这时的buffered channel类似于一个局部queue，对需要的节点进行处理，但这段代码的精妙之处在于，这里的block操作是select的，随时可以取消，而不是要等待或者对queue的长度有认识。

你对这三种channel的用法有什么疑问，欢迎讨论╮(╯▽╰)╭

0 0