GO语言学习笔记-Channels

2018-06-04

原文，建议先看完goroutine部分再看这篇。

什么是channels

channels可以理解成是goroutine之间通信的管道，和水流从管道的一端到另一端类似，数据也可以从管道的一端发送另一端接收。

声明channels

每个channel都需指定一个类型，这个类型是表明哪种类型的数据可以通过管道传输，而其他类型的不可以。

chan T指接受类型T的channel。

channel的默认值是nil，nil channel不能被任何类型使用所以和map或者slices一样，要使用make关键字来进行定义。

package main

import "fmt"

func main() {  
    var a chan int
    if a == nil {
        fmt.Println("channel a is nil, going to define it")
        a = make(chan int)
        fmt.Printf("Type of a is %T", a)
    }
}

上面声明了变量名为a的channel，并且默认值是nil，因此判断语句成立并且初始化类型为int的channel，程序输出如下：

channel a is nil, going to define it  
Type of a is chan int

通常我们使用一种更简洁的办法：

a := make(chan int)

发送和接收数据

语法如下：

data := <- a // read from channel a  
a <- data // write to channel a

箭头指向的方向表明了是读取还是接收数据。第一行，箭头向外指出，所以代表从a中读取数据并赋值给data变量。第二行，箭头指向a因此是向a中写入数据。

读写默认是阻塞行为

对channel进行读写操作默认是阻塞的，什么意思呢？当向channel写入数据时，程序被阻塞在写数据的语句处，直到有其他的goroutine从channel中读取。同样的，当从channel中读数据也会阻塞直到其他goroutine向其中写数据。

这种特性帮助goroutine之间进行高效通信，而不用像其他编程语言中那样使用显示声明锁或者条件变量来实现。

说完理论，我们来编写代码看看goroutine如何使用channel进行通信。我们先复习一下上一篇学习goroutine中的代码：

package main

import (  
    "fmt"
    "time"
)

func hello() {  
    fmt.Println("Hello world goroutine")
}
func main() {  
    go hello()
    time.Sleep(1 * time.Second)
    fmt.Println("main function")
}

我们使用Sleep来阻塞了main goroutine等待hello goroutine执行完毕，如果你对这个不理解，请看前一篇文章。

我们使用channel重写一下：

package main

import (  
    "fmt"
)

func hello(done chan bool) {  
    fmt.Println("Hello world goroutine")
    done <- true
}
func main() {  
    done := make(chan bool)
    go hello(done)
    <-done
    fmt.Println("main function")
}

上面程序中我们创建了名为done的布尔型channel并作为参数传递给了hello这个goroutine，１４行我们从done中读取数据，这行代码将被阻塞直到其他的goroutine向其中写入数据，因此不再需要Sleep来阻止main goroutine继续执行了。

<-done这行代码从channel中读取数据但不使用任何变量存储，这是符合语法的。

现在main goroutine被阻塞，等待done中的数据，hello接收这个channel作为参数，输出Hello world goroutine并且向done中写数据。当写入完成后，main goroutine从done中读取数据并且解除阻塞，接下来打印main function。

程序输出如下：

Hello world goroutine  
main function

再次引入Sleep来更好的理解阻塞的概念：

package main

import (  
    "fmt"
    "time"
)

func hello(done chan bool) {  
    fmt.Println("hello go routine is going to sleep")
    time.Sleep(4 * time.Second)
    fmt.Println("hello go routine awake and going to write to done")
    done <- true
}
func main() {  
    done := make(chan bool)
    fmt.Println("Main going to call hello go goroutine")
    go hello(done)
    <-done
    fmt.Println("Main received data")
}

上面代码中我们在hello中sleep４秒钟。

程序首先会输出Main going to call hello go goroutine并且启动goroutine并输出hello go routine is going to sleep。之后hello goroutine被阻塞4秒钟，与此同时main goroutine也会被阻塞，因为它需要在done中读取数据。４秒钟后将输出ello go routine awake and going to write to done和Main received data。

让我们来写一个更复杂的例子来理解channel，这个程序要求，输入一个数字，输出其每一位的平方和与立方和，并对这２者求和。比如我们输入123，则

squares = (1 * 1) + (2 * 2) + (3 * 3)

cubes = (1 * 1 * 1) + (2 * 2 * 2) + (3 * 3 * 3)

output = squares + cubes = 50

我们分别在squares goroutine和cubes goroutine中进行计算，并在main goroutine中进行最后求和。(roy注：可以先自己实现再看下面的答案)

package main

import (  
    "fmt"
)

func calcSquares(number int, squareop chan int) {  
    sum := 0
    for number != 0 {
        digit := number % 10
        sum += digit * digit
        number /= 10
    }
    squareop <- sum
}

func calcCubes(number int, cubeop chan int) {  
    sum := 0
    for number != 0 {
        digit := number % 10
        sum += digit * digit * digit
        number /= 10
    }
    cubeop <- sum
}

func main() {  
    number := 589
    sqrch := make(chan int)
    cubech := make(chan int)
    go calcSquares(number, sqrch)
    go calcCubes(number, cubech)
    squares, cubes := <-sqrch, <-cubech
    fmt.Println("Final output", squares + cubes)
    //　fmt.Println("Final output ", <-sqrch+<-cubech)　roy注　直接读出来也行
}

calcSquares和calcCubes进行并发计算并把结果存储到相应的channel中，main goroutine等待计算结果完成后输出：

Final output 1536

使用channel中一个非常重要的问题就是死锁，如果一个goroutine向channel中写入了数据，那么应该有其他的goroutine读取数据。如果没有，程序将报错Deadlock。类似的，如果goroutine等待从channel中读取数据，那么应该有其他的goroutine向channel中写入数据，否则程序也将报错。

package main


func main() {  
    ch := make(chan int)
    ch <- 5
}

上面的代码创建了channel ch并向其中写入5，但并没有goroutine从ch中读取数据，所以程序报错：

fatal error: all goroutines are asleep - deadlock!

goroutine 1 [chan send]:  
main.main()  
    /tmp/sandbox249677995/main.go:6 +0x80

单向channel

至今我们讨论的channel都是双向的，既可以写入也可读取数据。创建单向channel也是可以的，单向channel只能写入或者读取数据。

package main

import "fmt"

func sendData(sendch chan<- int) {  
    sendch <- 10
}

func main() {  
    sendch := make(chan<- int)
    go sendData(sendch)
    fmt.Println(<-sendch)
}

上面的代码中我们创建了一个只能写入数据的单向channel。chan<- int这个符号表明只能向这个channel写入数据，１２行我们尝试从这个channel中读取数据，程序将会报错：

main.go:11: invalid operation: <-sendch (receive from send-only type chan<- int)

但是呢，这种只能写入不能读取的channel有毛用啊？

有一种使用情况就是在channel转换时。我们可以将双向channel转换成单向channel，但反过来则不可以。

package main

import "fmt"

func sendData(sendch chan<- int) {  
    sendch <- 10
}

func main() {  
    chnl := make(chan int)
    go sendData(chnl)
    fmt.Println(<-chnl)
}

上面程序中我们创建了一个双向channel chnl，并把他作为参数传递给sendData，第５行函数通过sendch chan<- int将其转换为单向channel，所以在函数内部这个channel只能写入数据，而在main函数里chnl依然是个双向channel。程序将输出10。

关闭channel和range循环

发送方可以关闭channel来通知接收方没有更多数据传递了，而接收方可以使用额外的变量获取channel是否被关闭。

v, ok := <- ch

上面的代码中，如果ok的值是true则代表成功从channel获取到了值，为false则代表从一个已经关闭了的channel中读取数据，读取到的值为channel类型的默认值。比如从关闭的int类型的channel读取到的值是0。

package main

import (  
    "fmt"
)

func producer(chnl chan int) {  
    for i := 0; i < 10; i++ {
        chnl <- i
    }
    close(chnl)
}
func main() {  
    ch := make(chan int)
    go producer(ch)
    for {
        v, ok := <-ch
        if ok == false {
            break
        }
        fmt.Println("Received ", v, ok)
    }
}

上面的程序producer向chnl中写入0-9后关闭channel，main中使用for循环来检查channel是否被关闭，如果ok值为false则代表channel被关闭并且跳出循环，否则输出读取的值和ok：

Received  0 true  
Received  1 true  
Received  2 true  
Received  3 true  
Received  4 true  
Received  5 true  
Received  6 true  
Received  7 true  
Received  8 true  
Received  9 true

可以使用for range来读取数据直到channel被关闭：

package main

import (  
    "fmt"
)

func producer(chnl chan int) {  
    for i := 0; i < 10; i++ {
        chnl <- i
    }
    close(chnl)
}
func main() {  
    ch := make(chan int)
    go producer(ch)
    for v := range ch {
        fmt.Println("Received ",v)
    }
}

一旦channel关闭，循环将自动结束。程序输出和上面一样。

我们可以使用for range重写上面求和的程序来提高可重用性。如果你仔细观察，你将注意到从数字中提取某一位的代码是重复的，我们将这一步提取出来：

package main

import (  
    "fmt"
)

func digits(number int, dchnl chan int) {  
    for number != 0 {
        digit := number % 10
        dchnl <- digit
        number /= 10
    }
    close(dchnl)
}
func calcSquares(number int, squareop chan int) {  
    sum := 0
    dch := make(chan int)
    go digits(number, dch)
    for digit := range dch {
        sum += digit * digit
    }
    squareop <- sum
}

func calcCubes(number int, cubeop chan int) {  
    sum := 0
    dch := make(chan int)
    go digits(number, dch)
    for digit := range dch {
        sum += digit * digit * digit
    }
    cubeop <- sum
}

func main() {  
    number := 589
    sqrch := make(chan int)
    cubech := make(chan int)
    go calcSquares(number, sqrch)
    go calcCubes(number, cubech)
    squares, cubes := <-sqrch, <-cubech
    fmt.Println("Final output", squares+cubes)
}

digits函数包含提取数字逻辑并且被calcSquares和calcCubes函数并发调用，一旦没有更多位数需要提取，channel将被关闭。calcSquares和calcCubes函数各自使用for range循环读取channel中的数据，直到其被关闭。其他部分是一样的，程序将输出：

Final output 1536

接下来我们还要介绍关于channel更多的概念，比如buffered channels、worker pools、select，欢迎持续关注。

GO语言学习笔记-Channels

GO语言学习笔记-Channels

什么是channels

声明channels

发送和接收数据

读写默认是阻塞行为

单向channel

关闭channel和range循环

Recommend

Open source network management comparison podcast

Python 深入理解yield

Oodles of disk space, just not in the right place

Selenium+phantomjs模拟网页自动化操作

Hurrah! Some real data to play with

启用https提高网站安全性

A retrospective on Dyna Project version 0.1

127: Jonathan Reinink - Building Modern Monoliths with Inertia.js

HPACK: Header Compression for HTTP/2

Distributed network monitoring interview with Robert Aronsson

About Joyk