文章目录
概述
协程是并发编程的基础，而管道（channel）则是并发中协程之间沟通的桥梁，很多时候我们启动一个协程去执行完一个操作，执行操作之后我们需要返回结果，或者多个协程之间需要相互协作。
channel 基本使用
创建 channel
var ch0 chan int
var ch1 chan string
var ch2 chan map[string]string
type stu struct{}
var ch3 chan stu
var ch4 chan *stu
channel 方向 <-
ch <- v // 发送值v到Channel ch中
v := <-ch // 从Channel ch中接收数据，并将数据赋值给v
它包括三种类型的定义。可选的<-代表channel的方向。如果没有指定方向，那么Channel就是双向的，既可以接收数据，也可以发送数据。
chan T // 可以接收和发送类型为 T 的数据
chan<- float64 // 只可以用来发送 float64 类型的数据
<-chan int // 只可以用来接收 int 类型的数据
两个方向容易记混，这样，就默认我们是没有被显式写出的，那么 chan<- me 和 me <-chan 就好记了吧。
在通讯(communication)开始前channel和expression必选先求值出来(evaluated)，比如下面的(3+4)先计算出7然后再发送给channel。
c := make(chan int)
defer close(c)
go func() { c <- 3 + 4 }()
i := <-c
fmt.Println(i)
send被执行前(proceed)通讯(communication)一直被阻塞着。如前所言，无缓存的channel只有在receiver准备好后send才被执行。如果有缓存，并且缓存未满，则send会被执行往一个已经被close的channel中继续发送数据会导致run-time panic。往nil channel中发送数据会一致被阻塞着。
<-ch用来从channel ch中接收数据，这个表达式会一直被block,直到有数据可以接收。
从一个nil channel中接收数据会一直被block。
从一个被close的channel中接收数据不会被阻塞，而是立即返回，接收完已发送的数据后会返回元素类型的零值(zero value)。
如前所述，你可以使用一个额外的返回参数来检查channel是否关闭。
x, ok := <-ch
x, ok = <-ch
var x, ok = <-ch
如果OK 是false，表明接收的x是产生的零值，这个channel被关闭了或者为空。
make进行初始化
var ch0 chan int =make(chan int)
var ch1 chan int =make(chan int,10)
通过缓存的使用，可以尽量避免阻塞，提供应用的性能。
容量(capacity)代表Channel容纳的最多的元素的数量，代表Channel的缓存的大小。
如果没有设置容量，或者容量设置为0, 说明Channel没有缓存，只有sender和receiver都准备好了后它们的通讯(communication)才会发生(Blocking)。如果设置了缓存，就有可能不发生阻塞， 只有buffer满了后 send才会阻塞， 而只有缓存空了后receive才会阻塞。一个nil channel不会通信。
无缓存的与有缓存channel有着重大差别，那就是一个是同步的 一个是非同步的。
你可以在多个goroutine从/往 一个channel 中 receive/send 数据, 不必考虑额外的同步措施。
关闭 chan
这个要提一下，因为昨天写那个 “生成消费者” 就因为关闭出问题了。
使用内置函数close进行关闭，chan关闭之后，for range遍历chan中已经存在的元素后结束。
使用内置函数close进行关闭，chan关闭之后，没有使用for range的写法，需要使用，v, ok := <- ch进行判断chan是否关闭。
package main
import "fmt"
func main() {
var ch chan int
ch = make(chan int, 5)
for i := 0; i < 5; i++ {
ch <- i
}
close(ch)
for {
var b int
b, ok := <-ch
if ok == false {
fmt.Println("chan is close")
break
}
fmt.Println(b)
}
}
这个是很正常的。
如果将close(ch)注释掉，意思是不关闭管道，那么会出现dead lock死锁。因为存入管道5个数字，然后无限取数据，会出现死锁。
向 closed channel 发送数据引发 panic 错误，接收立即返回零值。而 nil channel， 无论收发都会被阻塞。
package main
func main() {
ch := make(chan int, 1)
close(ch)
ch <- 2
}
range 遍历 chan
package main
import "fmt"
func main() {
var ch chan int
ch = make(chan int, 10)
for i := 0; i < 10; i++ {
ch <- i
}
close(ch)
for v := range ch {
fmt.Println(v)
}
}
同样如果将close(ch)注释掉，意思是不关闭管道，那么会出现dead lock死锁。
内置函数len()、cap()
len 返回未被读取的缓冲元素数量，cap 返回缓冲区大小。
package main
import "fmt"
func main() {
ch1 := make(chan int)
ch2 := make(chan int, 3)
ch2 <- 1
fmt.Println(len(ch1), cap(ch1))
fmt.Println(len(ch2), cap(ch2))
}
select
select 语句类似于 switch 语句，但是select会随机执行一个可运行的case。如果没有case可运行，它将阻塞，直到有case可运行。
select语句选择一组可能的send操作和receive操作去处理。
package main
import (
"fmt"
)
func main() {
ch1 := make(chan int, 1)
ch1 <- 1
ch2 := make(chan int, 1)
ch2 <- 2
select { //随机读数
case k1 := <-ch1:
fmt.Println(k1)
case k2 := <-ch2:
fmt.Println(k2)
default:
fmt.Println("chan")
}
}
timeout
select有很重要的一个应用就是超时处理。 因为上面我们提到，如果没有case需要处理，select语句就会一直阻塞着。这时候我们可能就需要一个超时操作，用来处理超时的情况。
package main
import (
"fmt"
"time"
)
func main() {
c1 := make(chan string, 1)
go func() {
time.Sleep(time.Second * 2)
c1 <- "result 1"
}()
select {
case res := <-c1:
fmt.Println(res)
case <-time.After(time.Second * 1):
fmt.Println("timeout 1")
}
}
channel单向
可以将 channel 隐式转换为单向队列，只收或只发。
不能将单向 channel 转换为普通 channel。
package main
import (
"fmt"
)
func main() {
c := make(chan int, 3)
var send chan<- int = c // send-only
var recv <-chan int = c // receive-only
send <- 5 // <-send // Error: receive from send-only type chan<- int
val, ok := <-recv
if ok {
fmt.Println(val)
} // recv <- 2 // Error: send to receive-only type <-chan int
}
可以试着将 send 和 recv 的顺序反过来看看。
chan 作为 chan数
channel 是第一类对象，可传参 (内部实现为指针) 或者作为结构成员。
package main
import "fmt"
type Request struct {
data []int
ret chan int
}
func NewRequest(data ...int) *Request {
return &Request{data, make(chan int, 1)}
}
func Process(req *Request) {
x := 0
for _, i := range req.data {
x += i
}
req.ret <- x
}
func main() {
req := NewRequest(10, 20, 30)
Process(req)
fmt.Println(<-req.ret)
}
