Go语言通道与Goroutine：深度解析阻塞行为及程序终止规则

package main

import "fmt"

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

    // 以下代码若直接执行会引发死锁，因为主Goroutine发送后，没有接收方
    // c <- 1 // 主Goroutine在此处阻塞，等待接收方
    // fmt.Println("发送完成") // 永不会执行

    // 正确的无缓冲通道使用方式通常涉及并发Goroutine
    go func() {
        c <- 1 // 这个Goroutine会阻塞，直到main Goroutine接收
        fmt.Println("子Goroutine发送完成")
    }()

    val := <-c // main Goroutine在此处阻塞，等待发送方
    fmt.Println("主Goroutine接收到:", val) // 输出：主Goroutine接收到: 1
}

package main

import "fmt"

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

    c <- 1 // 缓冲区未满，不阻塞
    c <- 2 // 缓冲区未满，不阻塞

    // c <- 3 // 主Goroutine在此处阻塞，因为缓冲区已满，且没有接收方
    // fmt.Println("第三次发送完成") // 永不会执行

    fmt.Println("接收到:", <-c) // 接收一个元素，缓冲区变为 [2]
    fmt.Println("接收到:", <-c) // 接收一个元素，缓冲区变空 []

    // fmt.Println("接收到:", <-c) // 主Goroutine在此处阻塞，因为缓冲区已空，且没有发送方
}

package main

import (
    "fmt"
    "time"
)

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

    go func() { // 启动一个子Goroutine
        fmt.Println("子Goroutine: 尝试发送 1")
        c <- 1 // 缓冲区未满，不阻塞
        fmt.Println("子Goroutine: 尝试发送 2")
        c <- 2 // 缓冲区未满，不阻塞
        fmt.Println("子Goroutine: 尝试发送 3 (缓冲区已满，将阻塞)")
        c <- 3 // 缓冲区已满，子Goroutine在此处阻塞
        fmt.Println("子Goroutine: 成功发送 3") // 只有当main Goroutine接收后才会打印
    }()

    time.Sleep(100 * time.Millisecond) // 等待子Goroutine启动并发送前两个元素
    fmt.Println("主Goroutine: 继续执行，接收前...")

    // 主Goroutine从通道接收数据，这将解除子Goroutine的阻塞
    val1 := <-c
    fmt.Println("主Goroutine: 接收到:", val1) // 输出：主Goroutine: 接收到: 1

    time.Sleep(100 * time.Millisecond) // 再次等待，让子Goroutine有机会发送3
    val2 := <-c
    fmt.Println("主Goroutine: 接收到:", val2) // 输出：主Goroutine: 接收到: 2

    // 此时子Goroutine可能已经发送了3，或者仍然阻塞等待接收
    // 如果没有后续接收，子Goroutine将一直阻塞
}

package main

import (
    "time"
)

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

    // 场景一：主Goroutine直接写入导致死锁
    /*
    c <- 1
    c <- 2
    c <- 3 // 主Goroutine在此处阻塞，因为缓冲区已满，且没有接收方
    // 此时程序会报告 "all goroutines are asleep - deadlock!"
    */

    // 场景二：多个子Goroutine写入，主Goroutine等待
    for i := 0; i < 4; i++ {
        go func(idx int) {
            c