Go语言通道与Goroutine：深度解析阻塞行为与程序生命周期

package main

import "fmt"

func main() {
    c := make(chan int) // 创建一个无缓冲通道

    // 以下代码会立即导致死锁，因为主Goroutine发送后会阻塞，
    // 而没有其他Goroutine来接收。
    // c <- 1
    // fmt.Println(<-c)

    // 正确使用无缓冲通道通常需要Goroutine协作
    go func() {
        fmt.Println("Goroutine: Sending 1 to unbuffered channel")
        c <- 1 // 子Goroutine发送，会阻塞直到主Goroutine接收
    }()

    fmt.Println("Main: Receiving from unbuffered channel:", <-c) // 主Goroutine接收，解除子Goroutine阻塞
    fmt.Println("Main: Received 1")
}

package main

import (
    "fmt"
    "time"
)

func main() {
    c := make(chan int, 2) // 创建一个容量为2的有缓冲通道

    c <- 1 // 缓冲区未满，不阻塞
    c <- 2 // 缓冲区未满，不阻塞
    fmt.Println("Main: Sent 1 and 2 to buffered channel")

    // c <- 3 // 尝试发送第三个值，此时缓冲区已满，主Goroutine将在此处阻塞

    fmt.Println("Main: Receiving from buffered channel:", <-c) // 接收一个值，缓冲区腾出空间
    fmt.Println("Main: Current channel size:", len(c))

    // 结合Goroutine的缓冲通道
    go func() {
        fmt.Println("Goroutine: Sending 10 to buffered channel")
        c <- 10 // 缓冲区未满，不阻塞
        fmt.Println("Goroutine: Sending 20 to buffered channel")
        c <- 20 // 缓冲区已满，此Goroutine将在此处阻塞，直到main Goroutine接收
        fmt.Println("Goroutine: Sending 20 completed")
    }()

    time.Sleep(100 * time.Millisecond) // 等待子Goroutine运行
    fmt.Println("Main: Receiving from buffered channel:", <-c) // 接收，解除子Goroutine阻塞
    time.Sleep(100 * time.Millisecond)
    fmt.Println("Main: Receiving from buffered channel:", <-c) // 接收
}

package main

import (
    "fmt"
    "time"
)

func main() {
    c := make(chan int, 2) // 容量为2的缓冲通道

    go func() { // 启动一个子Goroutine
        fmt.Println("Goroutine: Attempting to send 1")
        c <- 1 // 缓冲区未满，不阻塞
        fmt.Println("Goroutine: Attempting to send 2")
        c <- 2 // 缓冲区未满，不阻塞
        fmt.Println("Goroutine: Attempting to send 3 (will block)")
        c <- 3 // 缓冲区已满，此Goroutine将在此处阻塞
        fmt.Println("Goroutine: Sending 3 completed") // 这行代码不会立即执行，直到有接收者
    }()

    time.Sleep(500 * time.Millisecond) // 主Goroutine等待一段时间
    fmt.Println("Main: Program exiting.")
    // 主Goroutine在此处正常退出，子Goroutine仍在阻塞中
}

package main

func main() {
    c := make(chan int, 2) // 容量为2的缓冲通道
    c <- 1
    c <- 2
    c <- 3 // 主Goroutine在此处尝试发送第三个值，但缓冲区已满，主Goroutine将阻塞。
           // 由于没有其他Goroutine来接收通道中的数据，主Goroutine将永远无法解除阻塞。
           // 此时，Go运行时会检测到所有Goroutine（这里只有main）都已阻塞且无法继续，从而报告死锁。
}

fatal error: all goroutines are asleep - deadlock!

package main

import "time"

func main() {
    c := make(chan int, 2) // 容量为2的缓冲通道

    for i := 0; i < 4; i++ {
        go func(idx int) { // 启动四个子Goroutine
            c <- idx // 第一个发送，可能不阻塞
            c <- 9   // 第二个发送，可能不阻塞
            c <- 9   // 第三个发送，很可能阻塞（因为通道容量为2，且有多个Goroutine竞争发送）
            c <- 9   // 第四个发送，几乎必然阻塞
            // 这些子Goroutine最终会因通道满而阻塞
        }(i)
    }

    time.Sleep(2000 * time.Millisecond) // 主Goroutine等待2秒
    // 2秒后，主Goroutine正常执行完毕并退出
    // 所有仍在阻塞的子Goroutine会被Go运行时强制终止，不会报告死锁。
}