详解Go多协程并发环境下的错误处理

引言

在go语言中，我们通常会用到panic和recover来抛出错误和捕获错误，这一对操作在单协程环境下我们正常用就好了，并不会踩到什么坑。但是在多协程并发环境下，我们常常会碰到以下两个问题。假设我们现在有2个协程，我们叫它们协程a和b好了：

• 如果协程a发生了panic，协程b是否会因为协程a的panic而挂掉？
• 如果协程a发生了panic，协程b是否能用recover捕获到协程a的panic？

答案分别是：会、不能。
那么下面我们来一一验证，并给出在具体的业务场景下的最佳实践。

问题一

如果协程a发生了panic，协程b是否会因为协程a的panic而挂掉？

为了验证这个问题，我们写一段程序：

package main

import (
  "fmt"
  "time"
)

func main() {

  // 协程a
  go func() {
    for {
      fmt.println("goroutine1_print")
    }
  }()

  // 协程b
  go func() {
    time.sleep(1 * time.second)
    panic("goroutine2_panic")
  }()

  time.sleep(2 * time.second)
}

首先主协程开启两个子协程a和b，a协程不停的循环打印goroutine1_print字符串；b协程在睡眠1s后，就会抛出panic（睡眠这一步为了确保在a跑起来开始打印了之后，b才会panic），主协程睡眠2s，等待a、b子协程全部执行完毕，主协程退出。最终打印结果如下：

...
goroutine1_print
goroutine1_print
goroutine1_print
goroutine1_print
goroutine1_print
goroutine1_print
goroutine1_print
goroutine1_print
goroutine1_print
goroutine1_print
goroutine1_print
goroutine1_print
panic: goroutine2_panicgoroutine1_print

goroutine1_print
goroutine goroutine1_print
19goroutine1_print
goroutine1_print
goroutine1_print
goroutine1_print
 [runninggoroutine1_print
]:
goroutine1_print
goroutine1_print
goroutine1_print
main.main.func2()
        /users/jiangbaiyan/go/src/awesomeproject/main.go:18 +0x46
created by main.main
        /users/jiangbaiyan/go/src/awesomeproject/main.go:16 +0x4d

我们可以看到，在协程b发生panic之前，协程a一直在打印字符串；然后协程a和panic交替打印字符串，最后主协程与协程a、b全部退出。所以我们可以看到，一个协程panic之后，是会导致所有的协程全部挂掉的，程序会整体退出，到这里我们就验证了第一个问题的答案。

至于panic和协程a交替打印的原因，可能是因为panic也需要打印字符串。因为打印也是需要时间的，当我们执行panic这一行代码的时候，到panic真正触发所有协程挂掉，是需要一定的时间的（尽管这个时间很短暂），所以再这一小段时间内，我们会看到交替打印的现象。

问题二

如果协程a发生了panic，其他协程是否能用recover捕获到协程a的panic？

还是类似上面那段代码，我们还可以再精简一下：

package main

import (
  "fmt"
  "time"
)

func main() {

  defer func() {
    if e := recover(); e != nil {
      fmt.println("recover_panic")
    }
  }()

  go func() {
    panic("goroutine2_panic")
  }()

  time.sleep(2 * time.second)
}

我们这次只开启一个协程，并在主协程中加入了recover，希望它能够捕获到子协程中的panic，但是结果未能如愿：

panic: goroutine2_panic

goroutine 6 [running]:
main.main.func2()
    /users/jiangbaiyan/go/src/awesomeproject/main.go:17 +0x39
created by main.main
    /users/jiangbaiyan/go/src/awesomeproject/main.go:16 +0x57

 
process finished with exit code 2

我们看到，recover并没有生效。所以，哪个协程发生了panic，我们就需要在哪个协程recover，我们改成这样：

package main

import (
  "fmt"
  "time"
)

func main() {

  go func() {
    defer func() {
      if e := recover(); e != nil {
        fmt.println("recover_panic")
      }
    }()
    panic("goroutine2_panic")
  }()

  time.sleep(2 * time.second)
}

结果成功打印recover_panic字符串：

recover_panic

process finished with exit code 0

所以我们的答案也得到了验证：协程a发生panic，协程b无法recover到协程a的panic，只有协程自己内部的recover才能捕获自己抛出的panic。

最佳实践

我们先假设有这样一个场景，我们要开发一个客户端，这个客户端需要调用2个服务，这2个服务没有任何先后顺序的依赖，所以我们可以开启2个goroutine，通过并发调用这两个服务来获得性能提升。那么这个时候我们刚才所谈到的问题一就成了问题。
通常来讲，我们不希望其中一个服务调用失败，另一个服务调用也跟着失败，而是要继续执行完其他几个服务调用逻辑，这个时候我们该怎么办呢？

聪明的你一定会想到，我在每个协程内部编写一个recover语句，让他接住每个协程自己可能会发生的panic，就能够解决一个协程panic而导致所有协程挂掉的问题了。我们编写如下代码，这就是在业务开发中，结合问题二解决问题一的最佳实践：

// 并发调用服务，每个handler都会传入一个调用逻辑函数
func goroutinenotpanic(handlers ...func() error) (err error) {

  var wg sync.waitgroup
  // 假设我们要调用handlers这么多个服务
  for _, f := range handlers {

    wg.add(1)
    // 每个函数启动一个协程
    go func(handler func() error) {

      defer func() {
        // 每个协程内部使用recover捕获可能在调用逻辑中发生的panic
        if e := recover(); e != nil {
          // 某个服务调用协程报错，可以在这里打印一些错误日志
        }
        wg.done()
      }()

      // 取第一个报错的handler调用逻辑，并最终向外返回
      e := handler()
      if err == nil && e != nil {
        err = e
      }
    }(f)
  }

  wg.wait()

  return
}

以上方法调用示例：

// 调用示例
func main() {

  // 调用逻辑1
  arpc := func() error {
    panic("rpc logic a panic")
    return nil
  }
  
  // 调用逻辑2
  brpc := func() error {
    fmt.println("rpc logic b")
    return nil
  }

  err := goroutinenotpanic(arpc, brpc)
  if err != nil {
    fmt.println(err)
  }
}

这样我们就实现了一个通用的并发处理逻辑，每次调用我们只需要把业务逻辑的函数传入即可，不用每次自己单独编写一套并发控制逻辑；同时调用逻辑2就不会因为调用逻辑1的panic而挂掉了，容错率更高。在业务开发中我们可以参考这种实现方式~

到此这篇关于详解go多协程并发环境下的错误处理的文章就介绍到这了,更多相关go多协程并发错误处理内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！