面试题：Go语言中通道与Goroutine结合时常见的死锁场景及解决办法

Question

在Go语言中，当使用通道（channel）与Goroutine协作时，常常会出现死锁的情况。请列举至少两种常见的死锁场景，并说明如何解决这些死锁问题。同时，请给出简单的示例代码来辅助说明。

Answer 1

常见死锁场景及解决方法

1. 无缓冲通道单向发送或接收

• 场景：在无缓冲通道上，如果只有发送操作而没有对应的接收操作，或者只有接收操作而没有对应的发送操作，就会导致死锁。因为无缓冲通道在进行发送操作时，会阻塞直到有其他Goroutine在该通道上进行接收操作；反之亦然。
• 解决方法：确保在使用无缓冲通道时，发送和接收操作能够匹配，一般通过启动Goroutine来进行发送和接收操作，避免在同一个Goroutine中出现单向的发送或接收而无匹配操作。
• 示例代码：

package main

import (
    "fmt"
)

func main() {
    ch := make(chan int)
    // 启动一个Goroutine进行接收
    go func() {
        num := <-ch
        fmt.Println("Received:", num)
    }()
    ch <- 42 // 发送数据
}

2. 缓冲通道满时发送或空时接收

• 场景：对于有缓冲通道，当通道已满，继续向通道发送数据会导致发送操作阻塞；当通道为空，继续从通道接收数据会导致接收操作阻塞。如果在这种阻塞状态下没有其他Goroutine来改变通道的状态（接收数据使通道不满，或发送数据使通道不空），就会产生死锁。
• 解决方法：合理规划缓冲通道的缓冲区大小，并确保在发送数据前检查通道是否已满，接收数据前检查通道是否为空。可以使用select语句结合default分支来实现非阻塞的发送和接收，或者确保有足够的Goroutine来处理通道中的数据。
• 示例代码：

package main

import (
    "fmt"
)

func main() {
    ch := make(chan int, 2)
    ch <- 1
    ch <- 2
    // 使用select结合default进行非阻塞发送
    select {
    case ch <- 3:
        fmt.Println("Successfully sent 3")
    default:
        fmt.Println("Channel is full, cannot send 3")
    }
    // 启动一个Goroutine来接收数据，避免空时接收阻塞
    go func() {
        for num := range ch {
            fmt.Println("Received:", num)
        }
    }()
}

3. 循环中无限制阻塞发送或接收

• 场景：在循环中进行通道操作时，如果没有合适的退出条件，可能会因为通道阻塞而导致死锁。例如，在一个循环中持续向已满的通道发送数据，而没有任何逻辑来处理通道已满的情况或退出循环。
• 解决方法：在循环中添加合适的退出条件，例如通过一个控制变量或者使用context来取消操作。同时，注意在合适的时机关闭通道，以避免接收端一直阻塞。
• 示例代码：

package main

import (
    "context"
    "fmt"
    "time"
)

func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    defer cancel()
    ch := make(chan int, 2)
    go func() {
        for {
            select {
            case <-ctx.Done():
                close(ch)
                return
            case ch <- 1:
            }
        }
    }()
    for num := range ch {
        fmt.Println("Received:", num)
        if num >= 5 {
            break
        }
    }
}

4. 通道操作的嵌套导致死锁

• 场景：当在一个Goroutine中嵌套进行通道操作，并且这些操作之间存在相互依赖和阻塞关系时，可能会导致死锁。例如，在一个Goroutine中先向一个通道发送数据，然后尝试从另一个通道接收数据，而另一个Goroutine可能也在等待从第一个Goroutine发送数据的通道接收数据后，才会向第二个通道发送数据，这样就形成了死锁。
• 解决方法：仔细设计Goroutine之间的协作逻辑，避免形成相互阻塞的依赖关系。可以通过调整操作顺序，或者引入中间状态变量来打破这种死锁循环。
• 示例代码：

package main

import (
    "fmt"
)

func main() {
    ch1 := make(chan int)
    ch2 := make(chan int)
    // 启动第一个Goroutine
    go func() {
        ch1 <- 1
        num := <-ch2
        fmt.Println("Goroutine 1 received from ch2:", num)
    }()
    // 启动第二个Goroutine
    go func() {
        <-ch1
        ch2 <- 2
        fmt.Println("Goroutine 2 sent to ch2")
    }()
    time.Sleep(1 * time.Second)
}

在这个示例中，如果没有两个Goroutine的启动，单纯在主函数中按照顺序执行通道操作就会导致死锁。通过启动Goroutine来并行执行这些操作，避免了死锁。