浅谈go语言channel通道造成的死锁问题

Bertha 。 2023-10-13 10:39 29阅读 0赞

go语言虽然号称协程之间必须使用channel通信，但是如果使用不当，非常容易形成deadlock死锁。下面的代码就是这样的一个例子

package main
    
    import "fmt"
    
    func doWork(id int, dataChan chan int, done chan bool) {
    	for data := range dataChan { 
    		fmt.Printf("Worker %d received %c\n", id, data)		
    		done <- true
    	}
    }
    
    func createChannels(id int) Worker {
    	ch := Worker{
    		data: make(chan int),
    		done: make(chan bool),
    	}
    	go doWork(id, ch.data, ch.done)
    	return ch
    }
    
    func chanRun() {
    	var channels [10]Worker
    	for i := 0; i < 10; i++ {
    		channels[i] = createChannels(i)
    	}
    
    	for i, ch := range channels {
    		ch.data <- 'a' + i
    		//<-ch.done
    	}
    
    	for i, ch := range channels {
    		ch.data <- 'A' + i
    		//<-ch.done
    	}
    
    	for _, ch := range channels {
    		<-ch.done
    		<-ch.done
    	}
    
    }
    
    type Worker struct {
    	data chan int
    	done chan bool
    }
    
    func main() {
    	chanRun()
    }

为什么会形成死锁？ 这里需要对无缓冲channel有深刻的理解。

**无缓冲channel需要发送方和接收方同时在线，只要有一方没有就位，就会引发死锁！**

在在doWork这段代码里，dataChan和done这两个通道是耦合在一起了，因为他们在一个同步代码块里，所以会出现互相等待的问题。 一旦其中一个通道被阻塞，另外一个通道也会因为等待陷入无法就绪状态，从而产生deadlock死锁问题。

这里的解决死锁的**关键就是解耦，**也就是将两个channel的因果关系破坏掉，避免互相等待。

具体来说：可以给其中的一个channel操作再开一个协程，也就是并发执行，这样就脱离了同步代码块，在这个例子里面，如下修改即可。

>     done <- true ==》 go func() { done <- true }()

func doWork(id int, dataChan chan int, done chan bool) {
    	for data := range dataChan { // 注意range是阻塞式读取channel，所以后面的done <- true如果不开协程也会被阻塞住
    		fmt.Printf("Worker %d received %c\n", id, data)
    		//给done这个channel单独再可一个协程，并发执行，脱离doWork主程序，
            // 从而避免dataChan和done这两个channel在同步代码块中的互相等待    
    		go func() { done <- true }()
    		//done <- true
    	}
    }

还有一个解决办法： 将两个通道中任意一个通道变成有缓冲通道

>     ch := Worker{
>        data: make(chan int,1),
>        done: make(chan bool),
>     }
> 
> 或者
> 
>     ch := Worker{
>        data: make(chan int),
>        done: make(chan bool,1),
>     }

此时done通道也就无需单独开协程。

因此我们使用无缓冲channel时一定要非常小心，为避免死锁, 总体有以下两大原则：

1. **尽量避免在同步代码中使用两个channel的情况，避免channel之间出现耦合、嵌套的情况，因为容易出现两个channel互相等待的问题; 如果确实没法避免，则必须给其中一个channel单独再开一个协程，类似于下面的代码：**

> go func() \{ channel <- data \}() // 通过匿名函数给channel再单独开一个协程

2. **往无缓冲channel发送数据时务必单独再开一个协程**

**如果没有把握处理好无缓冲channle，为了安全起见，建议使用有缓冲channel**

顺附：有缓冲channel和无缓冲channel的区别说明

有缓冲channel和无缓冲channel本质上就是一个同步和异步的区别。

无缓冲：就是完全同步，发送和接收方紧紧耦合在一起。

有缓冲： 异步工作。 通道未满之前，发送方和接收方各自独立工作：也就是都不会阻塞。这个有点类似于消息队列MQ.此时通道起到了解耦的作用。通道满了以后，就是同步通信，此时发送方阻塞。