敞开生长之旅！这是我参加「日新计划 2 月更文挑战」的第 24 天，点击检查活动详情
1 channel 3个状态
nil
正常channel 可读或可写
active
已封闭，千万不要误认为 channel封闭后，值为nil
closed
运用场景
广播，如消费者/生产者模型
交流数据
并发控制
显现告诉等
每个channel内部完成都有三个行列
接收消息的协程行列。
这个行列的结构是一个限制最大长度的链表，一切堵塞在channel的接收操作的协程都会被放在这个行列里。
发送消息的协程行列。
这个行列的结构也是一个限制最大长度的链表。一切堵塞在channel的发送操作的协程也都会被放在这个行列里。
环形数据缓冲行列。
这个环形数组的大小便是channel的容量。假如数组装满了，就表明channel满了，假如数组里一个值也没有，就表明channel是空的。对于一个堵塞型channel来说，它总是一起处于即满又空的状态。
1.1 channel 3个操作
读，写，封闭，3个操作和3个channel状态 有9种常见 场景
操作 channel处于nil channel处于 active channel处于closed
<-ch 堵塞 成功或堵塞 读到 0 值
ch <- 堵塞 成功或堵塞 panic
close(ch) panic 成功 panic
注：当nil通道在select的某个case时，这个case将堵塞，但不会形成死锁
- 支撑运用for range 读channel
1.2 运用 _,ok 判别channel是否封闭
if v, ok := <- ch; ok {
fmt.Println(v)
}
1.3 运用select处理多个channel
select一起监控多个 通道，只处理未堵塞的case，通道为nil，对应case永久堵塞，不管读写。
func (h *Handler) handler(job *Job) {
select {
case h.jobCh <- job:
return
case <-h.stopCh:
return
}
}
1.4 运用channel的声明控制读写权限
协程对某个通道只读或只写时
假如协程对某个channel只要写操作，则这个channel声明为只写。
假如协程对某个channel只要读操作，则这个channel声明为只读。
只要 generator进行对outCh进行写操作，回来声明。
<- chan int 可以避免其他协程乱用此通道，形成隐藏bug
func generator(int n) <- chan int {
outCh := make(chan int)
go func(){ # 匿名函数
for i:=0; i<n;i++{
outCh<-i
}
}()
return outCh
}
consumber 只读inCh数据，声明为 <- chan int，避免它向 inCh写数据
func consumer(inCh <- chan int){
for x := range inCh{
fmt.Println(x)
}
}
2 运用缓冲channel增强并发
无缓冲
ch1 := make(chan int)
ch2 := make(chan int, 0)
有缓冲
ch3 := make(chan int, 1)
func test() {
inCh := generator(100)
outCh := make(chan int, 10)
运用5个do协程一起处理输入数据
var wg sync.WaitGroup
wg.Add(5)
for i := 0; i < 5; i++ {
go do(inCh, outCh, &wg)
}
go func() {
wg.Wait()
close(outCh)
}()
for r := range outCh {
fmt.Println(r)
}
}
func generator(n int) <-chan int {
outCh := make(chan int)
go func() {
for i := 0; i < n; i++ {
outCh <- i
}
close(outCh)
}()
return outCh
}
func do(inCh <-chan int, outCh chan<- int, wg *sync.WaitGroup) {
for v := range inCh {
outCh <- v * v
}
wg.Done()
}
2.1 超时控制
看操作 和定时器 哪个先回来 就处理哪个
func doWithTimeOut(timeout time.Duration) (int, error) {
select {
case ret := <-do():
return ret, nil
case <-time.After(timeout):
return 0, errors.New("timeout")
}
}
func do() <-chan int {
outCh := make(chan int)
go func() {
// do work
}()
return outCh
}
2.2 channel 无堵塞读写
func unBlockRead(ch chan int) (x int, err error) {
select {
case x = <-ch:
return x, nil
case <-time.After(time.Microsecond):
return 0, errors.New("read time out")
}
}
func unBlockWrite(ch chan int, x int) (err error) {
select {
case ch <- x:
return nil
case <-time.After(time.Microsecond):
return errors.New("read time out")
}
}
2.3 封闭下流协程
可以运用WaitGroup等待一切协程退出
func (h *Handler) Stop() {
close(h.stopCh)
}
收到中止后，不再处理恳求
func (h *Handler) loop() error {
for {
select {
case req := <-h.reqCh:
go handle(req)
case <-h.stopCh:
return
}
}
}
2.4 运用 chan struct{} 作为信号 channel
上例中的Handler.stopCh便是一个例子，stopCh并不需要传递任何数据.
只是要给一切协程发送退出的信号，没有数据传递，则传递空 struct。
type Handler struct {
stopCh chan struct{}
reqCh chan *Request
}
2.5 运用 channel 传递结构体的指针，而非结构体本身
引荐：
reqCh chan *Request
不引荐：
reqCh chan Request
2.6 运用channel传递channel
场景，运用场景多：
package main
import (
"fmt"
"math/rand"
"sync"
"time"
)
存放成果的channel的channel
func main() {
reqs := []int{1, 2, 3, 4, 5, 6, 7, 8, 9}
outs := make(chan chan int, len(reqs))
var wg sync.WaitGroup
wg.Add(len(reqs))
for _, x := range reqs {
o := handle(&wg, x)
outs <- o
}
go func() {
wg.Wait()
close(outs)
}()
读取成果，成果有序
for o := range outs {
fmt.Println(<-o)
}
}
handle 处理恳求，耗时随机模仿
func handle(wg *sync.WaitGroup, a int) chan int {
out := make(chan int)
go func() {
time.Sleep(time.Duration(rand.Intn(3)) * time.Second)
out <- a
wg.Done()
}()
return out
}
小结
这儿和接下来几个章节 记载一些go常见的特征 和 运用场景。
敞开生长之旅！这是我参加「日新计划 2 月更文挑战」的第 24 天，点击检查活动详情