Go并发编程：理解与解决通道（Channel）操作中的常见死锁与竞态问题

package main

import (
    "fmt"
    "time"
)

func main() {
    go func() {
        fmt.Println("This goroutine might not print!") // 可能不打印
        time.Sleep(time.Second) // 尝试延长其生命周期，但主函数可能已退出
        fmt.Println("Goroutine finished.")
    }()
    // main函数立即退出，不会等待上面的goroutine
    // fmt.Println("Main function exiting.")
}

package main                                                                    

import (                                                                        
    "fmt"                                                                       
)                                                                               

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

    go func() { // 匿名函数不再接收count作为参数，直接使用外部的count
        current := 0                                                            
        for {                                                                   
            current = <-count // 1. 尝试从count接收数据
            current++                                                           
            count <- current  // 2. 将递增后的数据发送回count
            fmt.Printf("Goroutine processed: %d\n", current)
        }                                                                       
    }()

    // fmt.Println(<-count) // 3. 主goroutine也尝试从count接收数据
    // 此时会发生死锁
}

package main

import (
    "fmt"
    "time" // 引入time包用于演示，非核心逻辑
)

func main() {
    count := make(chan int) // 创建一个非缓冲整数通道

    // 启动一个goroutine来管理计数器状态
    go func() {
        current := 0 // 计数器的当前值
        for {
            current = <-count // 1. 从通道接收当前计数器值
            current++         // 2. 递增计数器
            count <- current  // 3. 将递增后的值发送回通道
            fmt.Printf("Goroutine: 接收 %d, 发送 %d\n", current-1, current)
            time.Sleep(time.Millisecond * 50) // 模拟一些工作
        }
    }()

    // 主goroutine发送初始值，并接收最终结果
    count <- 1 // 主goroutine向通道发送初始值 1
    fmt.Printf("Main: 第一次接收到 %d\n", <-count) // 主goroutine接收递增后的值 (2)

    count <- 10 // 主goroutine再次发送一个值 10
    fmt.Printf("Main: 第二次接收到 %d\n", <-count) // 主goroutine接收递增后的值 (11)

    // 为了防止主goroutine过早退出，可以添加一个阻塞操作
    // 例如：
    // select {} // 阻塞主goroutine，等待其他事件
    // 或者在实际应用中，使用 sync.WaitGroup 来等待所有goroutine完成
    time.Sleep(time.Second) // 简单地等待一段时间，以便观察goroutine输出
    fmt.Println("程序结束。")
}

package main

import (
    "fmt"
    "sync"
    "time"
)

func main() {
    var wg sync.WaitGroup
    count := make(chan int)

    wg.Add(1) // 告知WaitGroup有一个goroutine需要等待
    go func() {
        defer wg.Done() // goroutine结束时调用Done
        current := 0
        for i := 0; i < 3; i++ { // 限制循环次数以演示退出
            current = <-count
            current++
            count <- current
            fmt.Printf("Goroutine processed: %d\n", current)
            time.Sleep(time.Millisecond * 100)
        }
        // close(count) // 可以在适当的时候关闭通道，但需谨慎处理
    }()

    count <- 1
    fmt.Printf("Main received: %d\n", <-count)

    count <- 10
    fmt.Printf("Main received: %d\n", <-count)

    count <- 20
    fmt.Printf("Main received: %d\n", <-count)

    // 注意：如果goroutine有明确的退出条件，主goroutine需要确保发送足够的请求
    // 否则goroutine可能在wg.Done()之前就阻塞，导致死锁

    wg.Wait() // 主goroutine等待所有Add的goroutine都调用Done
    fmt.Println("所有goroutine已完成，程序结束。")
}