zhuo/blog

3种优雅的Go channel用法

写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:
1
2
3
Main 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
       }
   }
}

/* Output
1
2
3
B Quit
Main 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
        }
                // 在新的请求,超时和上层取消请求中select
        select {
        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)
                                                        // 将新的节点送入channel
                            request <- rn
                        }
                    }
                }
            }()
        case <-time.After(500 * time.Millisecond):
            break OUT // break至外层,否则仅仅是跳至loop外
            case <-ctx.Done():
            break OUT
        }
    }
    return
}

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

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