Go语言死锁和阻塞

news2026/2/13 13:50:24

在Go语言中，死锁和阻塞是并发编程中需要特别注意的问题。死锁和阻塞通常由于错误的channel使用或**goroutine之间未正确同步**造成。理解并发状态和避免死锁是编写并发安全程序的关键。

1. 阻塞和死锁的定义

阻塞：当一个goroutine等待一个未准备好的channel，或等待其他goroutine完成时，它会暂停，称之为阻塞。
死锁：当多个goroutine相互等待，或者主程序和goroutine之间形成循环等待关系时，整个程序卡死，无法继续执行。Go在检测到程序死锁时会产生运行时恐慌（panic: all goroutines are asleep - deadlock）。

2. 常见的死锁情况

情况 1：没有配对的发送和接收操作

无缓冲channel的发送和接收操作必须同步完成。如果没有接收者准备好接收，发送操作会一直阻塞，最终导致死锁。

package main

func main() {
    ch := make(chan int)
    ch <- 1 // 没有接收者，会导致死锁
}

在这个例子中：

ch <- 1会阻塞，因为没有任何goroutine在接收数据。程序会在这一行发生死锁。

情况 2：关闭的`channel`继续接收或写入数据

向关闭的channel写入数据会引发恐慌，而从已关闭的channel接收数据可以进行，但接收方应能检测到通道关闭后停止操作。

package main

func main() {
    ch := make(chan int)
    close(ch)
    ch <- 1 // 向已关闭的 channel 写入数据会引发 panic
}

3. `channel`导致的死锁解决方法

使用带缓冲的`channel`

有缓冲channel可以避免某些阻塞问题，因为它允许一定数量的数据在没有接收者的情况下进入缓冲区。

package main

import "fmt"

func main() {
    ch := make(chan int, 2) // 创建缓冲区大小为2的 channel
    ch <- 1
    ch <- 2
    fmt.Println(<-ch) // 输出：1
    fmt.Println(<-ch) // 输出：2
}

有缓冲的channel允许多个数据项进入，减少阻塞的风险。
但需注意：当缓冲区满时，发送操作仍然会阻塞。

使用`select`实现超时机制

select可以为channel操作添加超时，从而避免goroutine长时间阻塞。

package main

import (
    "fmt"
    "time"
)

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

    select {
    case data := <-ch:
        fmt.Println("Received:", data)
    case <-time.After(2 * time.Second): // 等待 2 秒超时
        fmt.Println("Timeout, no data received")
    }
}

在这个例子中：

如果2秒内ch没有数据到达，程序会触发超时分支，从而避免阻塞。

4. 典型的并发状态问题

状态问题 1：共享资源的并发访问

当多个goroutine访问同一个变量时，如果没有适当的同步控制，可能导致数据竞争问题，进而导致程序状态不一致。

解决方案：使用`sync.Mutex`进行互斥锁保护

package main

import (
    "fmt"
    "sync"
)

var counter int
var mutex sync.Mutex

func increment(wg *sync.WaitGroup) {
    defer wg.Done()
    mutex.Lock() // 加锁，防止其他 goroutine 访问 counter
    counter++
    mutex.Unlock() // 解锁
}

func main() {
    var wg sync.WaitGroup

    for i := 0; i < 10; i++ {
        wg.Add(1)
        go increment(&wg)
    }

    wg.Wait()
    fmt.Println("Counter:", counter)
}

在这个例子中：

使用sync.Mutex来保护counter，防止多个goroutine同时访问该变量。

状态问题 2：资源争用和竞争条件

多个goroutine尝试获取有限资源时，可能会引发竞争条件。一个常见的场景是多个goroutine尝试写入同一个channel，或同时对某个文件进行写操作。

解决方案：通过`sync.WaitGroup`确保`goroutine`顺序执行

使用sync.WaitGroup确保所有goroutine在主goroutine结束前完成，可以有效避免资源竞争和死锁。

package main

import (
    "fmt"
    "sync"
)

func worker(id int, wg *sync.WaitGroup) {
    defer wg.Done()
    fmt.Printf("Worker %d started\n", id)
    // 模拟工作
    fmt.Printf("Worker %d done\n", id)
}

func main() {
    var wg sync.WaitGroup

    for i := 1; i <= 5; i++ {
        wg.Add(1)
        go worker(i, &wg)
    }

    wg.Wait() // 等待所有 goroutine 完成
    fmt.Println("All workers done")
}