Go语言并发编程：优雅管理Goroutine生命周期与避免死锁

package main

import (
    "fmt"
    "strconv"
    "sync"
)

func worker(wg *sync.WaitGroup, cs chan string, i int) {
    defer wg.Done()
    cs <- "worker" + strconv.Itoa(i) // 工作Goroutine发送数据
}

func monitorWorker(wg *sync.WaitGroup, cs chan string) {
    defer wg.Done()
    // 死锁点：此循环会无限期等待cs通道，即使所有worker都已完成
    for i := range cs {
        fmt.Println(i)
    }
    // 当cs通道被关闭时，for range循环才会结束
}

func main() {
    wg := &sync.WaitGroup{}
    cs := make(chan string) // 创建一个无缓冲通道

    // 启动10个工作Goroutine
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go worker(wg, cs, i)
    }

    // 启动一个监控Goroutine
    wg.Add(1)
    go monitorWorker(wg, cs)

    // main Goroutine等待所有Goroutine完成
    wg.Wait() // 此处会永远阻塞，因为monitorWorker永不调用wg.Done()
}

package main

import (
    "fmt"
    "strconv"
    "sync"
)

func worker(wg *sync.WaitGroup, cs chan string, i int) {
    defer wg.Done()
    cs <- "worker" + strconv.Itoa(i)
}

// monitorWorker现在负责等待所有worker完成，然后关闭通道
func monitorWorker(wg *sync.WaitGroup, cs chan string) {
    wg.Wait() // 等待所有worker Goroutine完成
    close(cs) // 所有worker完成后，关闭通道
}

func main() {
    wg := &sync.WaitGroup{}
    cs := make(chan string)

    // 启动10个工作Goroutine
    for i := 0; i < 10; i++ {
        wg.Add(1) // 增加wg计数，用于worker Goroutine
        go worker(wg, cs, i)
    }

    // 启动一个monitorWorker Goroutine，它将等待所有worker完成并关闭cs通道
    // 注意：这里没有为monitorWorker增加wg计数，因为它不直接影响main的wg.Wait()
    // 它的作用是协调cs通道的关闭
    go monitorWorker(wg, cs)

    // main Goroutine现在作为消费者，从cs通道接收数据
    for i := range cs {
        fmt.Println(i)
    }
    // 当cs通道被monitorWorker关闭后，此for range循环会自然结束
    // main Goroutine将退出，程序终止
}

package main

import (
    "fmt"
    "strconv"
    "sync"
)

func worker(wg *sync.WaitGroup, cs chan string, i int) {
    defer wg.Done()
    cs <- "worker" + strconv.Itoa(i)
}

// monitorWorker 依然负责等待所有worker完成并关闭cs通道
func monitorWorker(wg *sync.WaitGroup, cs chan string) {
    wg.Wait()
    close(cs)
}

// printWorker 负责从cs通道接收并打印数据，并在完成时通过done通道通知
func printWorker(cs <-chan string, done chan<- bool) {
    for i := range cs {
        fmt.Println(i)
    }
    // 当cs通道关闭且所有数据被消费后，发送信号到done通道
    done <- true
}

func main() {
    wg := &sync.WaitGroup{}
    cs := make(chan string)

    // 启动10个工作Goroutine
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go worker(wg, cs, i)
    }

    // 启动monitorWorker，它会等待所有worker完成并关闭cs通道
    go monitorWorker(wg, cs)

    // 创建一个用于printWorker通知main Goroutine完成的通道
    done := make(chan bool, 1)
    // 启动printWorker Goroutine
    go printWorker(cs, done)

    // main Goroutine等待printWorker通过done通道发送完成信号
    <-done
    // 收到信号后，main Goroutine退出，程序终止
}