Go并发编程：深入理解Goroutine、Channel与死锁避免策略

package main

import "math/rand" // 注意：应使用 "math/rand" 而非 "rand"

func Routine1(command12 chan int, response12 chan int, command13 chan int, response13 chan int) {
    for i := 0; i < 10; i++ {
        y := rand.Intn(10)
        if y%2 == 0 {
            command12 <- y // 发送给 Routine2
        } else {
            command13 <- y // 发送给 Routine3
        }
        select {
        case cmd1 := <-response12: // 等待 Routine2 的响应
            print(cmd1, " 1st\n")
        case cmd2 := <-response13: // 等待 Routine3 的响应
            print(cmd2, " 1st\n")
        }
    }
    close(command12) // 示例中只关闭了一个，可能导致其他通道未关闭
}

func Routine2(command12 chan int, response12 chan int, command23 chan int, response23 chan int) {
    for i := 0; i < 10; i++ {
        select {
        case x, open := <-command12: // 接收 Routine1 的消息
            if !open { return }
            print(x, " 2nd\n")
        case x, open := <-response23: // 接收 Routine3 的响应
            if !open { return }
            print(x, " 2nd\n")
        }
        y := rand.Intn(10)
        if y%2 == 0 {
            response12 <- y // 响应 Routine1
        } else {
            command23 <- y // 发送给 Routine3
        }
    }
}

func Routine3(command13 chan int, response13 chan int, command23 chan int, response23 chan int) {
    for i := 0; i < 10; i++ {
        select {
        case x, open := <-command13: // 接收 Routine1 的消息
            if !open { return }
            print(x, " 3rd\n") // 注意：原代码中此处也为"2nd"，此处修正为"3rd"以示区分
        case x, open := <-command23: // 接收 Routine2 的消息
            if !open { return }
            print(x, " 3rd\n")
        }
        y := rand.Intn(10)
        if y%2 == 0 {
            response13 <- y // 响应 Routine1
        } else {
            response23 <- y // 响应 Routine2
        }
    }
}

func main() {
    command12 := make(chan int)
    response12 := make(chan int)
    command13 := make(chan int)
    response13 := make(chan int)
    command23 := make(chan int)
    response23 := make(chan int)

    go Routine1(command12, response12, command13, response13)
    go Routine2(command12, response12, command23, response23)
    Routine3(command13, response13, command23, response23) // 注意：此处缺少 'go' 关键字
}

go Routine1(...)
go Routine2(...)
Routine3(...) // 缺少 'go' 关键字

// 错误示例：主goroutine会阻塞
// MyFunc()

// 正确示例：MyFunc将在新的goroutine中并发执行
go MyFunc()

package main

import (
    "fmt"
    "sync"
    "time"
)

func worker(id int, wg *sync.WaitGroup) {
    defer wg.Done() // Goroutine完成时调用Done()
    fmt.Printf("Worker %d starting\n", id)
    time.Sleep(time.Second) // 模拟工作
    fmt.Printf("Worker %d finished\n", id)
}

func main() {
    var wg sync.WaitGroup
    for i := 1; i <= 3; i++ {
        wg.Add(1) // 每启动一个goroutine，计数器加1
        go worker(i, &wg)
    }
    wg.Wait() // 等待所有goroutine完成
    fmt.Println("All workers finished. Main goroutine exiting.")
}

// 创建一个容量为N的缓冲通道
bufferedChan := make(chan int, N)

// 发送操作：如果通道未满，发送不会阻塞
bufferedChan <- value

// 接收操作：如果通道非空，接收不会阻塞
receivedValue := <-bufferedChan