百木园今天这篇笔记我们来记录Channel 和 Select, Go语言并发中Channel是goroutine传递数据的桥梁，是非常重要的一个工具。
定义Channel
双向Channel
要定义一个channel很简单，只需要在类型前面加上chan就可以了，
stringStream := make(chan string)
这样就是定义和实例化了一个string 类型的双向channel,
先来看一个Hello World的例子
func main() {
stringStream := make(chan string)
go func() {
stringStream <- \"Hello channels\"
}()
fmt.Println(<-stringStream)
运行代码控制台打印出“Hello channels”, 这个简单的例子中我们定义了一个string类型的channel, 启动一个goroutine, 往这个channel中写入“Hello channels”， 主的goroutinue会读取这个channel里面的value, 读取是阻塞的，如果我们把写的代码注释掉“stringStream <- \"Hello channels\"”，程序运行会报死锁，因为没有谁会写入了，它一直等待。
单向Channel
我们也可以声明单向的channel，也就是只读或者只写的channel.
var receiveChan <-chan string //一个只读的channel
var sendChan chan<- string //一个只写的channel,
既然是只读，那么谁来给它写入呢， 这里其实还是需要一个双向的channel,然后把双向的channel赋值给单向channel,如
stringStream := make(chan string)
receiveChan = stringStream
sendChan = stringStream
只读和只写channel有什么作用呢？ 他们主要是用在方法的参数或者返回中，用户看到这个chan是只读的或者只写的就明确了它的使用方法。 对于只读的，我们实际上用个双向的channel，然后写入双向channel后， 把双向channel赋值给只读的channel. 如下示例代码
func main() {
stringStream := make(chan string)
go send(stringStream, \"passed message\")
receive(stringStream)
}
func send(pings chan<- string, msg string) {
fmt.Println(\"ping \" + msg)
pings <- msg
}
func receive(receiver <-chan string) {
fmt.Println(<-receiver)
}
我们在send方法中知道pings是只写的，不会读取它
在receive方法中知道receiver是只读的， 不会写它
读取和写入Channel
上面例子我们一件看到读就通过value := <-channel, 把channel中的数据读出来， 写就通过 channel<- value, 箭头方向也比较明确，比较好理解。这里再给个通过range读取channel的方法
先看示例代码
intStream := make(chan int)
go func() {
defer close(intStream)
for i := 1; i <= 5; i++ {
intStream <- i
fmt.Printf(\"writer %d \\n\", i)
}
}()
for integer := range intStream {
fmt.Printf(\"receive %v \\n\", integer)
}
fmt.Println(<-intStream)
fmt.Println(<-intStream)
我们写入了五个value到intStream里面， 读取的时候通过range我就不用知道这个次数了，通过for range 就都拿到了。 上面程序输出结果如下：
writer 1
receive 1
receive 2
writer 2
writer 3
receive 3
receive 4
writer 4
writer 5
receive 5
0
0
结果比较有意思， receive 2 跑到writer3的前面去了， 我猜测是这个channel是阻塞的，写入的时候，必须读了才能再写，读到1以后，2就可以写了，还没有来得及打印writer, read就拿到了。所以感觉上receive跑到writer前面去了。
最后两个00是我故意打印出来的，从关闭的channel也能拿到有返回的数据，如果想确定数据是不是正常写入的，可以加上 value,ok := <- intStream, 判断 ok 是true和false判断是否是正常写入的。
缓冲Channel
我们前面看到的例子，写入数据到channel后，必须等别的goroutine读到后才可以继续写，那么如果我想写入后继续去干别的，就需要用到缓冲Channel, 也就可以多写几个到channel。 如下示例代码
intStream := make(chan int, 2)
go func() {
defer close(intStream)
defer fmt.Println(\"Producer Done\")
for i := 0; i < 5; i++ {
intStream <- i
fmt.Printf(\"Sending: %d \\n\", i)
}
}()
time.Sleep(10 * time.Second)
for i := 0; i < 5; i++ {
v := <-intStream
fmt.Printf(\"Received: %d \\n\", v)
time.Sleep(1 * time.Second)
}
定义一个缓冲区为2的channel, 当写入两个后会被阻塞。 输出结果如下
Sending: 0
Sending: 1
Received: 0
Sending: 2
Received: 1
Sending: 3
Received: 2
Sending: 4
Producer Done
Received: 3
Received: 4
可以看到当发送了两个后，发送就阻塞起来了，直到读取了之后，才可以继续发送。
这里有个疑问点作者说 make(chan int) 和 make(chan int, 0) 是等效的，我实际验证效果也确实是一样的，但是我想不应该是make(chan int, 1) 吗？但是实际效果make(chan int, 1) 和make(chan int, 0) 确实不一样。 我实验了下，make(chan int, 1) 写第二个的时候被阻塞，用
make(chan int, 0)，写一开始就会阻塞，直到开始读了，写才会成功。当然不是先写后读，只是一种相互的阻塞状态。
Select
作者在书中写道：“Select是一个具有并发性的Go语言最重要的事情之一， 在一个系统中两个或者多个组件的交集中，可以在本地、单个函数、或者类型以及全局范围内查找select语句绑定在一起的channel。除了连接组件之外，在程序的某些关键节点上， select 语句可以帮助安全地将channel与诸如取消、超时、等待、默认值之类的概率结合起来”。
单一channel select
先来看一个简单的例子
start := time.Now()
c := make(chan interface{})
go func() {
time.Sleep(5 * time.Second)
close(c)
}()
fmt.Print(\"Blocking on read ... \\n\")
select {
case <-c:
fmt.Printf(\"Unblocked %v later. \\n\", time.Since(start))
}
程序输出结果如下, 等待5S后，关闭了channel, 阻塞结束。
Blocking on read ...
Unblocked 5.0101794s later.
上面是一个单一channel select的例子, 它等效于下面的语句
if c == nil {
block()
}
<- c
多个channel
接着我们看一个多个channel可用的例子， 我自己稍微改装了一下上面的例子
start := time.Now()
c := make(chan interface{})
c2 := make(chan int)
go func() {
time.Sleep(5 * time.Second)
for i := 0; i < 3; i++ {
c2 <- i
}
close(c)
}()
fmt.Print(\"Blocking on read ... \\n\")
loop:
for {
select {
case <-c:
fmt.Printf(\"Unblocked %v later. \\n\", time.Since(start))
break loop
case data := <-c2:
fmt.Printf(\"C2 received %d, %v later. \\n\", data, time.Since(start))
}
}
这里有两个case, 一个收到后会退出循环，一个会读取channel里面的数据，程序运行结果如下所示
Blocking on read ...
C2 received 0, 5.0148217s later.
C2 received 1, 5.0155568s later.
C2 received 2, 5.0161642s later.
Unblocked 5.0167839s later.
我们写入的3个数据都被读取到了，并且关闭channel后退出了循环。
书中还列举了一个当多个channel都可用的时候，Go 语言执行伪随机选择，
c1 := make(chan interface{})
close(c1)
c2 := make(chan interface{})
close(c2)
var c1Count, c2Count int
for i := 1000; i >= 0; i-- {
select {
case <-c1:
c1Count++
case <-c2:
c2Count++
}
}
fmt.Printf(\"c1Count:%d \\nc2Count: %d \\n\", c1Count, c2Count)
程序运行结果如下
c1Count:483
c2Count: 518
运行1000次，两个case比较平均的执行
超时
我们来看一个超时的例子
start := time.Now()
c1 := make(chan interface{})
select {
case <-c1:
fmt.Println(\"received c1.\")
case <-time.After(2 * time.Second):
fmt.Printf(\"Timed out. after %v later. \\n\", time.Since(start))
}
程序输出
Timed out. after 2.0099758s later.
没有程序写入c1, 所以在等待2S后，执行了time out.
default
来看default的例子
start := time.Now()
var c1, c2 <-chan interface{}
select {
case <-c1:
fmt.Println(\"received c1.\")
case <-c2:
fmt.Println(\"received c2.\")
default:
fmt.Printf(\"default after %v later. \\n\", time.Since(start))
}
程序几乎立刻执行了default, 输出如下
default after 0s later.
来源：https://www.cnblogs.com/dk168/p/16919372.html
本站部分图文来源于网络，如有侵权请联系删除。