Go语言中结构体通道的正确使用与死锁规避

ch := make(chan int)          // 声明一个用于传递int类型的无缓冲通道
bufferedCh := make(chan string, 10) // 声明一个用于传递string类型的有缓冲通道，容量为10

package main

import "fmt"

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

func main() {
    sliceData := make([][]int, 3)
    c := blah{make(chan [][]int)} // 创建一个无缓冲通道并嵌入结构体

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

    go func() {
        test := <- c.slice // 协程A：尝试从通道接收数据
        test = sliceData   // 这行代码将本地变量test赋值，但test目前为空
        c.slice <- test    // 协程A：尝试向通道发送数据（发送的是一个空值）
    }()

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

ch := make(chan int) // 无缓冲通道
go func() { <-ch }() // 协程A尝试接收
<-ch                 // 主协程尝试接收
// 结果：死锁，因为没有发送者

ch := make(chan int) // 无缓冲通道
go func() { ch <- 1 }() // 协程A尝试发送
ch <- 2                  // 主协程尝试发送
// 结果：死锁，因为无缓冲通道需要接收者才能完成发送

ch := make(chan int) // 无缓冲通道
ch <- 1              // 阻塞，等待接收者
i := <-ch            // 永远无法执行到这里，因为上面已经阻塞
// 结果：死锁

ch := make(chan int) // 无缓冲通道
go func() {
    ch <- 1 // 在一个Goroutine中发送
}()
i := <-ch // 在另一个Goroutine中接收
fmt.Println("Received:", i) // Output: Received: 1

ch := make(chan int, 1) // 有缓冲通道，容量为1
ch <- 1                 // 发送操作不会阻塞，因为缓冲区有空间
i := <-ch               // 接收操作
fmt.Println("Received:", i) // Output: Received: 1

package main

import "fmt"
import "time" // 引入time包用于演示延迟

type blah struct {
    dataChan chan [][]int // 更名为dataChan以提高可读性
}

func main() {
    sliceData := make([][]int, 3)
    sliceData[0] = []int{1, 2, 3}
    sliceData[1] = []int{4, 5, 6}
    sliceData[2] = []int{7, 8, 9}

    // 示例1：使用无缓冲通道，确保发送和接收并发
    fmt.Println("--- 示例1：无缓冲通道的正确使用 ---")
    c1 := blah{make(chan [][]int)}

    go func() {
        fmt.Println("Sender Goroutine (c1): Sending data...")
        c1.dataChan <- sliceData // 发送数据
        fmt.Println("Sender Goroutine (c1): Data sent.")
    }()

    fmt.Println("Main Goroutine (c1): Waiting to receive data...")
    receivedData1 := <-c1.dataChan // 接收数据
    fmt.Println("Main Goroutine (c1): Received data:", receivedData1)

    // 示例2：使用有缓冲通道
    fmt.Println("\n--- 示例2：有缓冲通道的正确使用 ---")
    c2 := blah{make(chan [][]int, 1)} // 创建一个容量为1的有缓冲通道

    go func() {
        fmt.Println("Sender Goroutine (c2): Sending data...")
        c2.dataChan <- sliceData // 发送数据，不会立即阻塞
        fmt.Println("Sender Goroutine (c2): Data sent.")
        // 可以继续发送，直到缓冲区满
        // c2.dataChan <- [][]int{{10}} // 如果容量是1，这里会阻塞，直到有接收者
    }()

    // 给予发送者一点时间，确保发送完成 (在实际应用中通常不需要显式sleep)
    time.Sleep(100 * time.Millisecond)

    fmt.Println("Main Goroutine (c2): Waiting to receive data...")
    receivedData2 := <-c2.dataChan // 接收数据
    fmt.Println("Main Goroutine (c2): Received data:", receivedData2)

    // 示例3：如果需要在同一个Goroutine中发送和接收，且通道为无缓冲，则需要额外的并发机制
    // 但通常不推荐这种模式，因为容易出错。更好的做法是拆分到不同Goroutine或使用缓冲通道。
    // 如果非要如此，可能需要一个中间Goroutine来传递。
}