巧妙使用WaitGroupt处理错误

2020-09-20T00:00:00+00:00

1. 写在前面

使用Go的众多好处之一是它在并发方面十分简单，而大家比熟悉的WaitGroups就是一个很好的例子。虽然在并发处理上十分的方便，但要想有效地处理并发和错误可能很棘手。

本篇文章旨在概述如何在不停止程序执行的情况下，运行多个goroutine并有效处理任何错误。

2. 具体实现

对于这个如何上，可以简单的概括为以下三点：

两个channel。这两个channel的作用是用于传递错误和传递WaitGroup何时完成。
一个groutine。主要作用是用于监听WaitGroup是否完成，如果完成了，将会关闭某个channel。
一个Select。它用于监听出现的错误或WaitGroup完成与否，无论谁先结束，那么Select就会先执行谁。

具体代码如下：

main.go

 package main

 import (
     "errors"
     "fmt"
     "sync"
 )

 // ErrorHandler 返回一个错误。
 func ErrorHandler() error {
     return errors.New("generated errors")
 }

 func main() {
     // 创建两个channel，一个用于传递错误，另一个表示WaitGroup是否结束。
     errCh := make(chan error)
     wgCh := make(chan bool)

     var wg sync.WaitGroup

     wg.Add(2)

     go func() {
         fmt.Println("WaitGroup 1st.")

         // 这里可以定义我们需要执行的操作

         wg.Done()
     }()

     go func() {
         fmt.Println("WaitGroup 2nd")

         // 返回自定义的错误
         if err := ErrorHandler(); err != nil {
             errCh <- err
         }

         wg.Done()
     }()

     go func() {
         wg.Wait()
         close(wgCh)
     }()

     // 当有错误返回或WaitGroup执行结束时会被执行。
     select {
     case <-wgCh:
         break
     case err := <-errCh:
         close(errCh)
         panic(err)
     }

     fmt.Println("Main func ended!")
 }

运行上述代码，我们可以得到以下的输出，也从而能验证我们已经基于此达到了我们的目的。

output

 PS C:\Users\jeffrey\Desktop\hello> go run main.go
 WaitGroup 1st.
 WaitGroup 2nd
 panic: generated errors.

 goroutine 1 [running]:
 main.main()
         C:/Users/jeffrey/Desktop/hello/main.go:53 +0x2a6
 exit status 2
 PS C:\Users\jeffrey\Desktop\hello>

欢迎关注我的微信公众号[double12gzh]：

goroutine切换背后那些事儿

2020-09-21T00:00:00+00:00

本文基于于GoLang 1.13。

1. 写在前面

微信公众号：[double12gzh]

个人主页: https://gzh.readthedocs.io

关注容器技术、关注Kubernetes。问题或建议，请公众号留言。

Goroutine很轻量，从资源消耗方面来看，它只需要一个2Kb的内存栈就可以运行；从运行时来看，它的运行成本也很低，将一个goroutine切换到另一个goroutine并不需要很多操作。

在进行讲解golang的切换之前，我们先High Level的看一下goroutine切换的相关内容。

2. 案例

golang会根据两种断点将goroutine调度到线程上：

当一个goroutine阻塞了。如：系统调用，mutex，或者通道。被阻塞的goroutine会进入睡眠模式/队列，让Go调度并运行一个等待的goroutine。被阻塞的goroutine进入睡眠模式/队列，允许Go调度

System Message: WARNING/2 (/home/docs/checkouts/readthedocs.org/user_builds/gzh/checkouts/latest/blogs/GoLang/2020-09-21-goroutine发生切换时背后发生了什么.rst, line 36)

Bullet list ends without a blank line; unexpected unindent.

和运行一个等待的goroutine。

在函数调用过程中，假如goroutine必须增长它的栈。这个断点允许Go调度另一个goroutine，避免正在运行的那个goroutine占用CPU。

在这两种情况下，运行调度器的g0会用另一个准备运行的goroutine替换当前的goroutine。然后，被选中的goroutine取代g0，从而在线程上运行。

如果您想了解更多关于g0的内容，请参考g0

将一个运行中的goroutine切换到另一个运行中的goroutine涉及到两个切换。

g-> g0。

g0-> 另一个g。

在GoLang中，groutine真的非常轻量。为了保存，它只需要两个东西：

goroutine是在哪一行停止的。即：在被调度前，goroutine是在哪一行停止的，当前要运行的指令被记录在程序计数器（PC）中。goroutine稍后将在同一点恢复。
存放goroutine的堆栈。这个堆栈的目的是为了方便再次运行时恢复其局部变量。

下面我们深入看一下。

3. PC（程序记数器）

为了便于举例，我将使用一个通过channel进行通信的goroutine来说明，这两个goroutine中，一个可以产生数据的，其它的用于消费数据。代码如下：

main.go

 package main

 import (
     "fmt"
     "sync"
 )

 const COUNT = 100

 func main() {
     var wg sync.WaitGroup

     c := make(chan int, 10)

     wg.Add(1)

     // 生产数据
     go func() {
         for i := 0; i < COUNT; i++ {
             c <- i
         }

         close(c)
         wg.Done()
     }()

     // 消费数据
     for i := 0; i < 3; i++ {
         wg.Add(1)

         go func() {
             for v := range c {
                 if v%2 == 0 {
                     fmt.Println(v)
                 }
             }
         }()
     }

     wg.Wait()
 }

消费者基本上会打印0到99的偶数，我们将重点关注第一个goroutine–生产者–向缓冲区添加数字。当缓冲区满了，它将在发送消息时阻塞。此时，Go要切换到g0，调度另一个goroutine。

如前所述，Go首先需要保存当前指令，以便在同一指令处恢复goroutine。程序计数器(PC)保存在goroutine的内部结构中。

上面的代码可以使用以下图来简单说明：

指令和它们的地址可以通过命令获取：

➜  hello go tool compile -N -l main.go
➜  hello ls | grep main.o
main.o

下面是生产者的一个示例：

➜  hello go tool objdump main.o

在函数runtime.chansend1上阻塞通道前，程序逐条指令执行。Go将当前的程序计数器保存到当前goroutine的内部属性中。在我们的例子中，Go保存程序计数器的地址是0x4268d0，这个地址是在runtime和方法runtime.chansend1内部的。

然后，当g0唤醒goroutine时，它将在同一指令处恢复，对数值进行循环并推入通道。

下面我们来谈谈goroutine切换过程中的栈管理。

4. 栈(stack)

在被阻塞之前，正在运行的goroutine有它的原始栈。这个堆栈包含临时内存，比如变量i:

然后，当它在通道上阻塞时，goroutine将和它的堆栈一起切换到g0，这个goroutine将会有一个更大的栈。

在切换之前，堆栈将被保存，以便在goroutine再次运行时恢复。

我们现在已经完整地了解了goroutine切换中涉及的不同操作。现在让我们看看它是如何影响性能的。

我们应该注意到，一些架构(比如arm)需要多保存一个寄存器LR(链接寄存器)。

5. 操作

为了测量goroutine切换可能需要的时间，我们将使用前面写的程序。然而，它并不能给出一个完美的性能视图，因为它可能取决于找到下一个要调度的goroutine所需的时间。这样goroutine的切换也会影响性能，从函数prolog的切换比从通道上阻塞的goroutine切换要做的操作更多。

我们来总结一下我们要测量的操作：

当前的g在通道上阻塞并切换到g0:
- PC和堆栈指针一起被保存在一个内部结构中
- g0被设置为正在运行的goroutine。
- g0的堆栈取代了当前的堆栈。
g0正在寻找一个新的goroutine来运行。
g0必须与所选的goroutine进行切换。
- PC和堆栈指针被从内部结构中提取出来。
- 程序跳转到获取的PC地址。

如下图：

从g到g0或g0到g的切换是最快的阶段。它们包含少量固定的指令，这一点与调度器检查许多源以寻找下一个要运行的goroutine的情况相反。根据运行程序的情况，这个阶段甚至可能需要更多的时间。

需要说明的一点是，对于以上测试的结果会因机器架构的不同而不同

欢迎关注我的微信公众号：

double12gzh - Posts in GoLang

巧妙使用WaitGroupt处理错误

1. 写在前面

2. 具体实现

goroutine切换背后那些事儿

1. 写在前面

2. 案例

3. PC（程序记数器）

4. 栈(stack)

5. 操作