Go 编程模式 -- Pipeline

发表于 2年以前 | 总阅读数：476 次

流水线工作模型在工业领域内十分常见，它将工作流程分为多个环节，每个环节根据工作强度安排合适的人员数量。良好的流水线设计尽量让各环节的流通率平衡，最大化提高产能效率。

Go 是一门实用性语言，流水线工作模型与 Go 融合地非常融洽，只不过我们一般使用另一个名词来表示流水线：pipeline。

pipeline

pipeline 由多个环节组成，具体在 Go 中，环节之间通过 channel 通信，同一个环节任务可以由多个 goroutine 来同时处理。

图片

pipeline

pipeline 的核心是数据，通过 channel 来保证数据流动，每个环节的数据处理由 goroutine 完成。

除了开始环节和结束环节，每个环节都有任意数量的输入 channel 和输出 channel。开始环节被称为发送者或生产者，结束环节被称为接收者或消费者。

下面我们来看一个简单的 pipeline 例子，分为三个环节。

第一个环节，generate 函数：它充当生产者角色，将数据写入 channel，并把该 channel 返回。当所有数据写入完毕，关闭 channel。

func generate(nums ...int) <-chan int {
 out := make(chan int)
 go func() {
  for _, n := range nums {
   out <- n
  }
  close(out)
 }()
 return out
}

第二个环节，square 函数：它是数据处理的角色，从开始环节中的 channel 取出数据，计算平方，将结果写入新的 channel ，并把该新的 channel 返回。当所有数据计算完毕，关闭该新 channel。

func square(in <-chan int) <-chan int {
 out := make(chan int)
 go func() {
  for n := range in {
   out <- n * n
  }
  close(out)
 }()
 return out
}

main 函数负责编排整个 pipeline ，并充当消费者角色：读取第二个环节的 channel 数据，打印出来。

func main() {
 // Set up the pipeline.
 c := generate(2, 3)
 out := square(c)

 // Consume the output.
 for n := range out {
  fmt.Println(n)
 }
}

Fan-out,fan-in

在上述例子中，环节之间通过非缓冲的 channel 传递数据，节点中的数据都是单个 goroutine 处理与消费。

这种工作模式并不高效，会让整个流水线的效率取决于最慢的环节。因为每个环节中的任务量是不同的，这意味着我们需要的机器资源是存在差异的。任务量小的环节，尽量占有少量的机器资源，任务量重的环节，需要更多线程并行处理。

以汽车组装为例，我们可以将组装轮胎的工作分发给 4 个人一起干，当轮胎组装完毕之后，再交由剩下的环节。

多个 goroutine 可以从同一个 channel 读取数据，直到该通道关闭，这称为 fan-out（扇出）。

这个称呼比较形象，它将数据进行分散，所以被称为扇出。扇出是一种分发任务的模式。

图片

fan-out

单个 goroutine 可以从多个输入 channel 中读取数据，直到所有输入都关闭。具体做法是将输入 channel 多路复用到同一个 channel 上，当所有输入 channel 都关闭时，该 channel 也关闭，这称为 fan-in（扇入）。

它将数据进行聚合，所以被称为扇入。扇入是一种整合任务结果的模式。

图片

fan-in

在汽车组装的例子中，分发轮胎任务给每个人是 Fan-out，合并轮胎组装结果就是 Fan-in。

channel 的多路复用

扇出的编码模型比较简单，本文不多研究，我们提供一个扇入编程示例。

创建一个生成器函数 generate，通过 interval 参数控制消息生成频率。生成器返回消息 channel mc与停止 channel sc，停止 channel 用于停止生成器任务。

func generate(message string, interval time.Duration) (chan string, chan struct{}) {
 mc := make(chan string)
 sc := make(chan struct{})

 go func() {
  defer func() {
   close(sc)
  }()

  for {
   select {
   case <-sc:
    return
   default:
    time.Sleep(interval)

    mc <- message
   }
  }
 }()

 return mc, sc
}

stopGenerating 函数通过通过向 sc 中传入空结构体，通知 generate退出，调用 close(mc) 关闭消息 channel

func stopGenerating(mc chan string, sc chan struct{}) {
 sc <- struct{}{}

 close(mc)
}

多路复用函数 multiplex 创建并返回整合消息 channel 和控制并发的 wg。

func multiplex(mcs ...chan string) (chan string, *sync.WaitGroup) {
 mmc := make(chan string)
 wg := &sync.WaitGroup{}

 for _, mc := range mcs {
  wg.Add(1)

  go func(mc chan string, wg *sync.WaitGroup) {
   defer wg.Done()

   for m := range mc {
    mmc <- m
   }
  }(mc, wg)
 }

 return mmc, wg
}

在 main 函数中，创建两个消息 channel 并复用它们生成 mmc ，打印来自 mmc 的每条消息。另外，我们还实现了接收系统断信号（终端上执行 CTRL+C 即可发送中断信号）的优雅的关闭机制。

func main() {
 // create two sample message and stop channels
 mc1, sc1 := generate("message from generator 1", 200*time.Millisecond)
 mc2, sc2 := generate("message from generator 2", 300*time.Millisecond)

 // multiplex message channels
 mmc, wg1 := multiplex(mc1, mc2)

 // create errs channel for graceful shutdown
 errs := make(chan error)

 // wait for interrupt or terminate signal
 go func() {
  sc := make(chan os.Signal, 1)
  signal.Notify(sc, syscall.SIGINT, syscall.SIGTERM)
  errs <- fmt.Errorf("%s signal received", <-sc)
 }()

 // wait for multiplexed messages
 wg2 := &sync.WaitGroup{}
 wg2.Add(1)
 go func() {
  defer wg2.Done()

  for m := range mmc {
   fmt.Println(m)
  }
 }()

 // wait for errors
 if err := <-errs; err != nil {
  fmt.Println(err.Error())
 }

 // stop generators
 stopGenerating(mc1, sc1)
 stopGenerating(mc2, sc2)
 wg1.Wait()

 // close multiplexed messages channel
 close(mmc)
 wg2.Wait()
}