关于golang:基于channel的通信模型实践

前言

channel 作为 Go 外围的数据结构和 Goroutine 之间的通信形式，Channel 是撑持 Go 语言高性能并发编程模型的重要构造本节会介绍管道 Channel 的设计原理、数据结构和常见操作，例如 Channel 的创立、发送、接管和敞开。

在进入主题内容之前，读者须要先把握下表中的不同状态下的 channel 执行 Read、Write、close 操作所会产生的后果。

图来自 曹大

Go 语言中最常见的、也是常常被人提及的设计模式就是：不要通过共享内存的形式进行通信，而是应该通过通信的形式共享内存。尽管咱们在 Go 语言中也能应用共享内存加互斥锁进行通信，然而 Go 语言提供了一种不同的并发模型，即通信顺序进程（Communicating sequential processes，CSP）。Goroutine 和 Channel 别离对应 CSP 中的实体和传递信息的媒介，Goroutine 之间会通过 Channel 传递数据。本文将会介绍基于 channel 实现的多种通信模型。

MPSC: 多生产者单消费者模型
对于 MPSC 的利用场景中，多个生产者负责生产数据，只有一个消费者来生产数据，而这个模型又可分为两种实现形式：

1. 多个生产者是专用一个 channel 来和消费者通信
2. 应用本人独有的 channel 来和消费者通信

变种一：生产者共用 channel

如图所示，右边有多个生产 goroutine 往公共的 channel 中写入数据，左边只有一个生产 goroutine 从这个 channel 中读取数据进行解决。

根底版
咱们首先定义传递的音讯构造体定义:

`type Msg struct {

in int

}`

而后实现生产者如下，其中参数 sendChan 就是生产者和消费者进行通信的 channel

// 生产者
func producer(sendChan chan Msg) {
    for i := 0; i < 10; i++ {sendChan <- Msg{in: i}
    }
}

消费者以及音讯处理函数定义如下，其中参数 sendChan 就是生产者和消费者进行通信的 channel，以后音讯处理函数 process 目前只是把音讯内容打印进去。

// 消费者
func consumer(sendChan chan Msg) {
    for v := range sendChan {process(v)
    }
}

// 音讯处理函数
func process(msg Msg){fmt.Println(msg)
}

mpsc 的模型代码如下，首先创立通信用的 channel，而后开启三个生产者 goroutine，一个消费者 goroutine。

func mpsc() {sendChan := make(chan Msg, 10)

    for p := 0; p < 3; p++ {go producer(sendChan)
    }

    go consumer(sendChan)
}

main 函数如下, 外面 select{} 是为了放弃 main 函数所在的 goroutine 始终阻塞，不然 main 函数立即退出后，生产者和消费者 goroutine 说不定还没有执行或只执行了一部分就退出了。

`func main() {

mpsc()
select{}

}`

残缺代码 在线演示 https://www.online-ide.com/IB… 后果如下

{0}
{1}
{2}
{3}
{4}
{5}
{6}
{7}
{8}
{9}
{0}
{1}
{2}
{3}
{4}
{5}
{6}
{7}
{8}
{9}
{0}
{1}
{2}
{3}
{4}
{5}
{6}
{7}
{8}
{9}
fatal error: 
all goroutines are asleep - deadlock!
goroutine 1 [select (no cases)]:
main.main()
    /home/kingeasternsun/1ba7ba19-5e66-4f4c-beb3-cb5e3e6d881e/main.go:9 +0x25
goroutine 9 [chan receive]:
main.consumer(0xc000072000)
    /home/kingeasternsun/1ba7ba19-5e66-4f4c-beb3-cb5e3e6d881e/main.go:25 +0xa9
created by main.mpsc
    /home/kingeasternsun/1ba7ba19-5e66-4f4c-beb3-cb5e3e6d881e/main.go:43 +0x9b
exit status 2


** Process exited - Return Code: 1 **

能够看到打印的数字是由穿插的，阐明多个生产者并发的执行了写入。不过最初生产者发送完后程序有两个报错：

1. 第一条 goroutine 1 [select (no cases)]: 是指 select{} 始终阻塞
2. 第二条 goroutine 9 [chan receive]: 是指在于生产者发送完数据库后没有新的数据写入 channel，而消费者生产完 channel 中的数据库，再从空的 channel 中读数据就会统一阻塞，所以下面报 fatal error: all goroutines are asleep – deadlock! 这个谬误

因为咱们是 demo，为了放弃 main 活着应用了 select{}，理论我的项目中 mspc 往往会在一个继续运行的程序中调用，所以就没有下面的问题了。​

当然咱们也能够间接来修复这个谬误，让生产者都发送完后给消费者发消息让其退出即可。

修复 deadlock 问题
要等生产者都发送完后才给消费者发消息，那么咱们就须要应用 sync.WaitGroup 来进行同步。生产者如何给消费者发消息，同时要保障消费者把之前的音讯解决完后才退出。咱们能够又两种计划：

1. 发送一个非凡标记的 Msg，标记这个音讯是终止音讯
2. close channel

第 1 种计划会造成通信额定的内存占用耗费，举荐第 2 种计划。​

首先批改生产者代码如下，入参多了一个 wg *sync.WaitGroup，生产者发送完数据后调用 wg.Done()

// 生产者
func producer(sendChan chan Msg, wg *sync.WaitGroup) {
    for i := 0; i < 10; i++ {sendChan <- Msg{in: i}
    }

    wg.Done()}

而后 mpsc 模型改写为如下：

func mpsc() {

    // 生产者个数
    pNum := 3
    sendChan := make(chan Msg, 10)

    wg := sync.WaitGroup{}
    wg.Add(pNum)
    for p := 0; p < pNum; p++ {go producer(sendChan, &wg)
    }

    // 期待生产者都实现后敞开 sendChan 告诉到 消费者
    go func() {wg.Wait()
        close(sendChan)
    }()

    consumer(sendChan)
}

能够看到在 mpsc 中有以下几个变动

1. 新起了一个 goroutine，利用 wg.Wait()期待生产者都实现，而后去敞开 channel；
2. consumer(sendChan) 不再新起一个 goroutine 来执行，这样 mspc 就变成阻塞的，期待消费者失常完结。

因为 mpsc 自身是阻塞的了，所以咱们在 main 中只须要调用 mpsc 即可

`func main() {

mpsc()

}`

残缺代码

生产者消费者双向通信
以后模型中，生产者把音讯发送给消费者后，并不知道音讯解决的后果，如果生产者想要晓得音讯的处理结果，该如何改变呢？其中一个比拟常见的办法就是每个生产者保护一个本人公有的 channel，而后在发送音讯的时候，把本人公有的 channel 连同音讯一起发送给消费者，消费者解决音讯后，再将处理结果通过音讯中的 channel 发送回生产者。​

首先音讯类型定义中新增一个 channel 成员，用于存储生产者的公有 channel

type Msg struct {
    in int
    ch chan int
}

生产者开始的时候会新建一个独有的 channel，而后在发送音讯的时候把这个通道放入到 Msg 中，同时生产者会新启一个 goroutine 从这个独有的 channel 中承受消费者返回的效应。

// 生产者
func producer(sendChan chan Msg, wg *sync.WaitGroup) {recvCh := make(chan int)
    go func() {
        for v := range recvCh {fmt.Println("recv", v)
        }
    }()

    for i := 0; i < 10; i++ {sendChan <- Msg{in: i, ch: recvCh}
    }

    wg.Done()}

最初批改音讯处理函数如下，将承受的音讯中的 value 加倍后通过音讯中的 channel 传递回去。

// 音讯处理函数
func process(msg Msg) {msg.ch <- 2 * msg.in}

残缺代码​

​
目前为止生产者给消费者发送音讯是专用一个 channel，还有一种计划时生产者应用本人独有的 channel 给消费者发送音讯。​

变种二：生产者应用独有的 channel 和消费者通信

在这种计划中，每一个生产者保护一个独有的 channel 和消费者通信，消费者监听这些 channel 来获取音讯进行解决。

根底版

对于生产者，会创立一个独有的 channel，返回进来给消费者读取，同时外部新起一个 goroutine 来往这个 channel 中发送数据，代码如下：

func producer(in []int) chan Msg {ch := make(chan Msg)
    go func() {
        for _, v := range in {ch <- Msg{in: v}
        }
        close(ch)
    }()
    return ch
}

消费者会同时监听多个生产者的 channel 读取音讯，对应的消费者如下：

func consumer(ch1, ch2 chan Msg) {
    for {
        select {
        case v1 := <-ch1:
            fmt.Println(v1)
        case v2 := <-ch2:
            fmt.Println(v2)
        }
    }
}

对应的 mpsc 模型如下

func mpsc() {ch1 := producer([]int{1, 2, 3})
    ch2 := producer([]int{4, 5, 6})

    consumer(ch1, ch2)
}

残缺代码 ​

理论执行的时候会发现问题，当所有生产者发送完数据 close 本人的 channel 后，消费者还在不停的从 channel 外面承受数据，不过接管的数据值都是 0. 其中起因在于 close 的通道依然时可读的，读取的时候理论会返回两个值，第一个值是个零值，第二个值是一个 bool 值，标识以后通道是否 close 了，所以咱们在代码中要读取这个 bool 值来判断以后的 channel 是否敞开。另外 select 中的多个 channel 可能其中一个敞开了，然而其它的 channel 并没有 close，依然有数据可读，那如何让消费者跳过曾经 close 的 channel 呢？咱们能够把曾经敞开的 channel 设置为 nil，读写 nil 的 channel 都是阻塞的，所以在 select 中就会跳过这些 channel 了。​

修复版

依据上文所说，咱们要做以下几点的批改

1. 读取 channel 的敞开标记，来判断以后 channel 是否 close 了
2. 如果以后 channel 曾经 close 了，那么就将以后 channel 设置为 nil
3. 当所有的 channel 都敞开了，消费者就退出

代码如下：

func consumer(ch1, ch2 chan Msg) {
    var v1 Msg
    var v2 Msg
    ok1 := true
    ok2 := true

    for ok1 || ok2 {
        select {
        case v1, ok1 = <-ch1:
            fmt.Println(v1)
            if !ok1 { // 通道敞开了
                ch1 = nil
            }
        case v2, ok2 = <-ch2:
            fmt.Println(v2)
            if !ok2 { // 通道敞开了
                ch2 = nil
            }
        }
    }
}

残缺代码

SPMC：单生产者多消费者模型

如图，单个生产者和多个消费者之间通过共有的一个 channel 进行通信，生产者往 channel 外面写音讯，多个消费者争抢着从 channel 中读取音讯进行解决，这个模型十分像一个音讯队列中的 FanOut 模型。​

生产者负责往 channel 写音讯，写完后敞开 channel

func producer(ch chan Msg) {in := []int{1, 2, 3, 4, 5, 6}
    for _, v := range in {ch <- Msg{in: v}
    }
    close(ch)

}

消费者负责从 channel 中读取音讯

func consumer(ch chan Msg) {
    for v := range ch {fmt.Println(v)
    }
}

spmc 模型代码如下：

func spmc() {ch := make(chan Msg)
    go producer(ch)
    go consumer(ch)
    go consumer(ch)
    go consumer(ch)

}

spmc 模型解决敞开特地不便，因为只有一个生产者，所以生产者发送完音讯后就能够 close 这个 channel，而后上游的消费者都能够在 channel 中数据被读完后主动退出。for range 操作 channel 的时候，如果读取到 channel 返回的 bool 值是 false 就会退出循环。​

因为 spmc 外面生产者和消费者都是异步的，所以 main 只有放弃始终阻塞能力让逻辑失常执行。

`func main() {

spmc()
select {}

}`

残缺代码 ​

另外一种常见的写法如下，producer 在外部创立 channel 而后返回进来 ​

func producer() chan Msg {in := []int{1, 2, 3, 4, 5, 6}
    ch := make(chan Msg)
    go func() {
        for _, v := range in {ch <- Msg{in: v}
        }
        close(ch)
    }()
    return ch
}

而后消费者从 producer 返回的 channel 中读取音讯。spmc 模型如下

func spmc() {ch := producer()
    go consumer(ch)
    go consumer(ch)
    go consumer(ch)

}

残缺代码 ​