Golang并发编程：深入理解通道（Channel）的死锁机制

package main

import "fmt"

type blah struct {
    slice chan [][]int // 一个无缓冲的[][]int类型通道
}

func main() {
    dataToSend := make([][]int, 3)
    c := blah{make(chan [][]int)} // 初始化结构体，通道为无缓冲

    dataToSend[0] = []int{1, 2, 3}
    dataToSend[1] = []int{4, 5, 6}
    dataToSend[2] = []int{7, 8, 9}

    go func() {
        // 尝试从通道接收数据
        test := <- c.slice 
        // 将局部变量dataToSend赋值给test，但这并不会将数据发送回通道
        test = dataToSend 
        // 尝试向通道发送数据（此行在上一行接收成功前不会执行）
        c.slice <- test 
    }()

    // 主Goroutine尝试从通道接收数据
    fmt.Println(<-c.slice) 
}

package main

import "fmt"

func main() {
    ch := make(chan int, 1) // 创建一个容量为1的缓冲通道
    ch <- 1                 // 发送数据，不会阻塞，因为通道有空间
    i := <-ch               // 接收数据
    fmt.Println("Buffered channel example:", i) // 输出：Buffered channel example: 1
}

package main

import "fmt"

func main() {
    ch := make(chan int) // 创建一个无缓冲通道
    go func() {
        ch <- 1 // 在一个Goroutine中发送数据
    }()
    i := <-ch // 在另一个Goroutine（主Goroutine）中接收数据
    fmt.Println("Unbuffered channel concurrent example:", i) // 输出：Unbuffered channel concurrent example: 1
}

package main

// import "fmt" // 此代码会死锁，无需运行

func main() {
    ch := make(chan int)
    go func() { ch <- 1 }() // 第一个发送尝试
    ch <- 2                 // 第二个发送尝试，会阻塞，因为没有接收方
    // fmt.Println(<-ch) // 如果加上这行，可能接收到1，但2仍会阻塞
}

package main

// import "fmt" // 此代码会死锁，无需运行

func main() {
    ch := make(chan int)
    go func() { <-ch }() // 第一个接收尝试
    <-ch                 // 第二个接收尝试，会阻塞，因为没有发送方
}

package main

import "fmt"
import "time" // 用于演示延迟

type blah struct {
    slice chan [][]int
}

func main() {
    dataToSend := make([][]int, 3)
    c := blah{make(chan [][]int)} // 无缓冲通道

    dataToSend[0] = []int{1, 2, 3}
    dataToSend[1] = []int{4, 5, 6}
    dataToSend[2] = []int{7, 8, 9}

    // 启动一个Goroutine作为发送方
    go func() {
        fmt.Println("发送方Goroutine: 准备发送数据...")
        // 模拟一些工作
        time.Sleep(100 * time.Millisecond) 
        c.slice <- dataToSend // 向通道发送数据
        fmt.Println("发送方Goroutine: 数据已发送。")
    }()

    // 主Goroutine作为接收方
    fmt.Println("主Goroutine: 正在等待接收数据...")
    receivedData := <-c.slice // 从通道接收数据
    fmt.Println("主Goroutine: 接收到数据:", receivedData)

    // 为了确保Goroutine有时间执行，可以等待一下，或者使用sync.WaitGroup
    time.Sleep(500 * time.Millisecond)
}