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

[[426205]]

引言

在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而挂掉了，容错率更高。在业务开发中我们可以参考这种实现方式~

本文转载自微信公众号「NoSay」，可以通过以下二维码关注。转载本文请联系NoSay公众号。

本文名称：Go多协程并发环境下的错误处理
文章位置：http://www.shufengxianlan.com/qtweb/news4/335404.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联