写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
("Main quit")
}
func B() {
for {
select {
case i := <-g:
(i + 1)
case <-quit:
("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的退出了
("Main Quit")
}
func B() {
for {
select {
case i := <-g:
(i + 1)
case c := <-quit:
c <- true
("B Quit")
return
}
}
}
/* Output
1
2
3
B Quit
Main Quit
*/
分布式递归调用
在现实生活中，如果你要找美国总统聊天，你会怎么做？第一步打电话给在美国的朋友，然后他们也会发动自己的关系网，再找可能认识美国总统的人，以此类推，直到找到为止。这在Kadmelia分布式系统中也是一样的，如果需要获取目标ID信息，那么就不停地查询，被查询节点就算没有相关信息，也会返回它觉得最近节点，直到找到ID或者等待超时。 好了，这个要用Go来实现怎么做呢？
func recursiveCall(ctx , 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 := (ctx, n, MethodFindValue, id)
select {
case <-():
case msg :=<-response:
seen[responseToNode(response)] = n //更新已见过的节点信息
// 加载新的节点
for _, rn := range LoadNodeInfoFromByte(msg[PayLoadStart:]) {
()
_, ok := seen[()]
()
// 见过了，跳过这个节点
if ok {
continue
}
AddNode(rn)
// 将新的节点送入channel
request <- rn
}
}
}
}()
case <-(500 * ):
break OUT // break至外层，否则仅仅是跳至loop外
case <-():
break OUT
}
}
return
}
这时的buffered channel类似于一个局部queue，对需要的节点进行处理，但这段代码的精妙之处在于，这里的block操作是select的，随时可以取消，而不是要等待或者对queue的长度有认识。
你对这三种channel的用法有什么疑问，欢迎讨论╮(╯▽╰)╭