Golang并发编程：理解结构体中通道的使用与避免死锁

package main

import "fmt"

type blah struct {
    slice chan [][]int // 注意：这是一个通道，其元素类型是 [][]int
}

func main() {
    // 准备一些数据
    dataSlice := make([][]int, 3)
    dataSlice[0] = []int{1, 2, 3}
    dataSlice[1] = []int{4, 5, 6}
    dataSlice[2] = []int{7, 8, 9}

    // 初始化结构体，其中包含一个无缓冲通道
    c := blah{make(chan [][]int)}

    // 启动一个Goroutine
    go func() {
        // Goroutine尝试从通道接收数据
        test := <-c.slice // 第一次接收操作
        // 接收到数据后，将dataSlice赋值给test（这行代码在死锁发生后才可能执行）
        test = dataSlice
        // 尝试向通道发送数据（这行代码在第一次接收成功后才可能执行）
        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("Received:", i) // 输出：Received: 1
}

package main

import (
    "fmt"
    "time"
)

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

    // 启动一个Goroutine作为发送者
    go func() {
        fmt.Println("Sender: Sending 1...")
        ch <- 1 // 发送数据，会阻塞直到有接收者
        fmt.Println("Sender: 1 sent.")
    }()

    // 主Goroutine作为接收者
    fmt.Println("Receiver: Waiting to receive...")
    i := <-ch // 接收数据，会阻塞直到有发送者
    fmt.Println("Receiver: Received:", i) // 输出：Receiver: Received: 1

    time.Sleep(10 * time.Millisecond) // 确保Goroutine有时间执行
}

package main

import (
    "fmt"
    "time"
)

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

    go func() {
        fmt.Println("Goroutine 1: Trying to send 1...")
        ch <- 1 // Goroutine 1 尝试发送，会阻塞
        fmt.Println("Goroutine 1: 1 sent.")
    }()

    // 主Goroutine尝试发送
    fmt.Println("Main Goroutine: Trying to send 2...")
    ch <- 2 // 主Goroutine尝试发送，会阻塞
    fmt.Println("Main Goroutine: 2 sent.")

    time.Sleep(10 * time.Millisecond) // 这行代码不会被执行到
}

package main

import (
    "fmt"
    "time"
)

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

    go func() {
        fmt.Println("Goroutine 1: Trying to receive...")
        <-ch // Goroutine 1 尝试接收，会阻塞
        fmt.Println("Goroutine 1: Received.")
    }()

    fmt.Println("Main Goroutine: Trying to receive...")
    <-ch // 主Goroutine尝试接收，会阻塞
    fmt.Println("Main Goroutine: Received.")

    time.Sleep(10 * time.Millisecond) // 这行代码不会被执行到
}

package main

import (
    "fmt"
    "time" // 引入 time 包用于演示
)

// blah 结构体包含一个用于传递 [][]int 类型数据的通道
type blah struct {
    dataChan chan [][]int
}

func main() {
    // 准备要发送的数据
    dataToSend := make([][]int, 3)
    dataToSend[0] = []int{1, 2, 3}
    dataToSend[1] = []int{4, 5, 6}
    dataToSend[2] = []int{7, 8, 9}

    // 初始化结构体，其中包含一个无缓冲通道
    c := blah{make(chan [][]int)}

    // 启动一个Goroutine作为“生产者”
    go func() {
        fmt.Println("Producer Goroutine: Preparing to send data...")
        // 生产者向通道发送数据
        c.dataChan <- dataToSend
        fmt.Println("Producer Goroutine: Data sent.")
    }()

    // 主Goroutine作为“消费者”
    fmt.Println("Consumer Main: Waiting to receive data...")
    // 消费者从通道接收数据
    receivedData := <-c.dataChan
    fmt.Println("Consumer Main: Received data:", receivedData)

    // 确保有足够的时间让 Goroutine 完成其任务
    // 在这个例子中，接收会等待发送，所以通常不需要额外的延迟
    time.Sleep(100 * time.Millisecond)
}