[Go语言] Go语言死锁与goroutine泄露问题的解决

• 什么时候会导致死锁
  
• 发送单个值时的死锁
  
• 多个值发送的死锁
  
• 解决多值发送死锁
  
• 应该先发送还是先接收
  
• goroutine 泄漏
  
• 如何发现泄露
  
• 小结
  

   

• 数据要发送，但是没有人接收   
  
• 数据要接收，但是没有人发送
  

a := make(chan int)
a <- 1   //将数据写入channel
z := <-a //从channel中读取数据

   

• 有且只有一个协程时，无缓冲的通道   
  
• 先发送会阻塞在发送，先接收会阻塞在接收处。   
  
• 发送操作在接收者准备好之前是阻塞的，接收操作在发送之前是阻塞的，
  

chanInt := make(chan int)
go func() {
  chanInt <- 1
}()
res := <-chanInt

chanInt := make(chan int,1)
chanInt <- 2
res := <-chanInt

   

• 缓冲通道内部的消息数量用len()函数可以测试出来   
  
• 缓冲通道的容量可以用cap()测试出来   
  
• 在满足cap>len时候，因为没有满，发送不会阻塞   
  
• 在len>0时，因为不为空，所以接收不会阻塞
  

func multipleDeathLock() {
 chanInt := make(chan int)
 defer close(chanInt)
  go func() {
  res := <-chanInt
  fmt.Println(res)
 }()
 chanInt <- 1
 chanInt <- 1
}

fatal error: all goroutines are asleep - deadlock!
goroutine 1 [chan send]:
main.multipleDeathLock()

func multipleLoop() {
 chanInt := make(chan int)
 defer close(chanInt)
 go func() {
  for {
   //不使用ok会goroutine泄漏
   //res := <-chanInt
   res,ok := <-chanInt
   if !ok {
         break
      }
   fmt.Println(res)
  }
 }()
 chanInt <- 1
 chanInt <- 1
}

1
1

   

• 给通道的接收加上二值，ok 代表通道是否正常，如果是关闭则为false值   
  
• 可以删掉那段逻辑试试，会输出1 2 0 0 0这样的数列，因为关闭是需要时间的，而循环接收关闭的通道拿到的是0   
  
• 关于goroutine泄漏稍后会讲到
  

func multipleDeathLock2() {
 chanInt := make(chan int)
 defer close(chanInt)
 go func() {
  chanInt <- 1
  chanInt <- 2
 }()
 for {
  res, ok := <-chanInt
  if !ok {
   break
  }
  fmt.Println(res)
 }
}

输出死锁
1
2
fatal error: all goroutines are asleep - deadlock!
goroutine 1 [chan receive]:
main.multipleDeathLock2()

   

• 出现上面的结果是因为for循环一直在获取通道中的值，但是在读取完1 2后，通道中没有新的值传入，这样接收者就阻塞了。   
  
• 为什么先接收再发送可以，因为发送提前结束后会触发函数的defer自动关闭通道   
  
• 所以我们应该总是先接收后发送，并由发送端来关闭
  

   

• 当一个 goroutine 完成了它的工作   
  
• 由于发生了没有处理的错误   
  
• 有其他的协程告诉它终止
  

func goroutineLeak() {
 chanInt := make(chan int)
 defer close(chanInt)
 go func() {
  for {
      res := <-chanInt
   //res,ok := <-chanInt
   //if !ok {
      //   break
      //}
   fmt.Println(res)
  }
 }()
 chanInt <- 1
 chanInt <- 1
}

输出，如果程序不停止就会一直输出0
1
1
0
0
0
...

func goroutineLeakNoClosed() {
 chanInt := make(chan int)
 go func() {
  for {
      res := <-chanInt
   fmt.Println(res)
  }
 }()
}

   

• 无任何输出的阻塞   
  
• 换成写入也是一样的   
  
• 如果是有缓冲的通道，换成已满的通道写没有读；或者换成向空的通道读没有写也是同样的情况   
  
• 除了阻塞，goroutine进入死循环也是泄露的原因
  

   

• 使用 golang 自带的pprof监控工具，可以发现内存上涨情况，这个后续会讲   
  
• 还可以监控进程的内存使用情况，比如prometheus提供的process-exporter   
  
• 如果你有内存泄露/goroutine 泄露代码扫描的工具，欢迎留言，感恩！
  

   

• 如果是信号通知，应该保证一一对应，不然会死锁   
  
• 除了信号通知外，通常我们使用循环处理通道，在工作中不断的处理数据   
  
• 应该总是先接收后发送，并由发送端来关闭，不然容易死锁或者泄露   
  
• 在接收处，应该对通道是否关闭做好判断，已关闭应该退出接收，不然会泄露   
  
• 小心 goroutine 泄漏，应该在通道关闭的时候及时检查通道并退出   
  
• 除了阻塞，goroutine进入死循环也是泄露的原因