golang面试基础系列-解锁deadlock(四)

2,385 阅读2分钟

go 中经常会使用 channel,进行并发执行子任务,提高执行效率。但一不小心就会踩到 deadlock 的坑,本文就来解析一下常见的死锁形式和解决方式。

1. 直接读取空 chan 产生死锁

package main

import (
  "fmt"
)

func main() {
  ch := make(chan int, 3)
  <-ch
}

输出结果:

fatal error: all goroutines are asleep - deadlock!

goroutine 1 [chan receive]:
main.main()
  /home/work/code/golang/src/interview/go/deadlock/test.go:9 +0x56

Process finished with exit code 2

解决方式:

采用 select case default 阻塞默认处理方式。

package main

import (
  "fmt"
)

func main() {
  ch := make(chan int, 3)

  select {
  case v := <-ch:
    fmt.Println(v)
  default:
    fmt.Println("chan no data")
  }
}

2. 阻塞 channel 产生死锁

package main

import "fmt"

func main() {
  ch := make(chan int)

  ch <- 1 // 无缓冲在此写入数据,却没有读数据,阻塞住

  fmt.Println(<-ch) // 被上面阻塞,无法被执行到
}

输出结果:

fatal error: all goroutines are asleep - deadlock!

goroutine 1 [chan send]:
main.main()
  /home/work/code/golang/src/interview/go/deadlock/test02.go:8 +0x59

Process finished with exit code 2

解决方式:

a. 采用开启子协程方式,保证读写 chan 成对存取数据;

package main

import "fmt"

func main() {
  ch := make(chan int)

  go func() {
    ch <- 1 // 开启子goroutine写入数据
  }()

  fmt.Println(<-ch) // 阻塞住,一旦ch有数据,则读取成功
}

b. 采用有缓冲 chan,在容量范围内不会阻塞;

package main

import "fmt"

func main() {
  ch := make(chan int, 1)

  ch <- 1

  fmt.Println(<-ch)
}

3. 有缓冲 chan 超过容量时产生死锁

package main

import (
  "fmt"
)

func main() {
  ch := make(chan int, 3)
  ch <- 1
  ch <- 2
  ch <- 3
  ch <- 4 // 超过最大容量,阻塞main协程,产生deadlock

  for v := range ch {
    fmt.Println(v)
  }
}

解决方式:

a. 增加缓冲容量,保证能满足写入所有数据;

b. 采用 select case default 阻塞默认处理方式(demo略);

4. for range 产生死锁

package main

import (
  "fmt"
)

func main() {
  ch := make(chan int, 3)

  ch <- 1
  ch <- 2
  ch <- 3

  // range 一直读取直到chan关闭,否则产生阻塞死锁
  for v := range ch {
    fmt.Println(v)
  }
}

输出结果:

1
2
3
fatal error: all goroutines are asleep - deadlock!

goroutine 1 [chan receive]:
main.main()
  /home/work/code/golang/src/interview/go/deadlock/test04.go:15 +0x115

Process finished with exit code 2

解决方式:

a. 显式关闭 channel

b. 开启子协程,主协程 sleep 等待时间后退出;

package main

import (
  "fmt"
  "time"
)

func main() {
  ch := make(chan int, 3)

  ch <- 1
  ch <- 2
  ch <- 3

  close(ch) // 解决方式1:关闭chan

  // range 一直读取直到chan关闭,否则产生阻塞死锁
  // 解决方式2:开启子协程,主协程sleep等待
  go func() {
    for v := range ch {
      fmt.Println(v)
    }
  }()

  time.Sleep(1e9)
}

【小结】

  1. 日常在使用 channel 中,要注意区分有缓冲(buffered channel,异步队列-FIFO处理)与无缓冲(unbuffered channel,同步流入流出)通道的区别,掌握各自适合使用的方式;

  2. 出现deadlock一定是线程/协程之间存在了资源竞争,互相占用对方需要的资源导致程序永远不能退出,需要小心可能遇到的坑,也可以通过加锁避免。

稻草人生