1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

package main

import (
    "fmt"
    "time"
)

func main() {
    // 启动一个 goroutine
    go sayHello() // 告诉 Go："异步执行这个函数！"

    // 主 goroutine 继续执行
    fmt.Println("主函数：我先干点别的...")
    time.Sleep(time.Second) // 等一秒，不然主函数退出会把其他 goroutine 也带走
}

func sayHello() {
    fmt.Println("你好！我是另一个 goroutine！")
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

package main

import "fmt"

func main() {
    // 创建一个整数类型的 channel
    ch := make(chan string)

    // goroutine 发送数据
    go func() {
        msg := "你好，主函数！"
        fmt.Println("Goroutine: 我要发送消息了！")
        ch <- msg // 发送，阻塞直到主函数接收
        fmt.Println("Goroutine: 消息发送完成！")
    }()

    // 主函数接收数据
    fmt.Println("主函数: 等待接收消息...")
    received := <-ch // 接收，阻塞直到 goroutine 发送
    fmt.Println("主函数: 收到了:", received)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

package main

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

func main() {
    // 查看 CPU 核心数
    fmt.Printf("CPU 核心数: %d\n", runtime.NumCPU())
    fmt.Printf("当前 GOMAXPROCS: %d\n", runtime.Gomaxprocs(0))

    // 并发：交替执行
    fmt.Println("\n=== 并发执行 ===")
    var wg sync.WaitGroup
    for i := 1; i <= 3; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            for j := 1; j <= 3; j++ {
                fmt.Printf("Goroutine %d: 第 %d 次执行\n", id, j)
                time.Sleep(10 * time.Millisecond)
            }
        }(i)
    }
    wg.Wait()

    // 并行：设置 GOMAXPROCS = CPU 核心数
    fmt.Println("\n=== 并行执行（利用多核）===")
    runtime.Gomaxprocs(runtime.NumCPU()) // 设置为 CPU 核心数
    for i := 1; i <= 3; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            for j := 1; j <= 3; j++ {
                fmt.Printf("Goroutine %d: 第 %d 次执行\n", id, j)
                time.Sleep(10 * time.Millisecond)
            }
        }(i)
    }
    wg.Wait()
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

package main

import (
    "fmt"
    "time"
)

func main() {
    // 方式1：调用普通函数
    go sayHello()

    // 方式2：调用匿名函数
    go func() {
        fmt.Println("我是匿名 goroutine！")
    }()

    // 方式3：调用带参数的函数
    name := "Go语言"
    go sayName(name)

    // 等等，别让主函数跑太快！
    time.Sleep(time.Second)
    fmt.Println("主函数结束")
}

func sayHello() {
    fmt.Println("你好！")
}

func sayName(name string) {
    fmt.Printf("我是 %s\n", name)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

package main

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

func main() {
    // GOMAXPROCS 默认等于 CPU 核心数
    fmt.Printf("GOMAXPROCS: %d\n", runtime.Gomaxprocs(0))

    // 创建一个 channel 来同步
    done := make(chan bool)

    for i := 0; i < 3; i++ {
        go func(id int) {
            fmt.Printf("Goroutine %d 正在执行\n", id)
            time.Sleep(100 * time.Millisecond)
            done <- true
        }(i)
    }

    // 等待所有 goroutine 完成
    for i := 0; i < 3; i++ {
        <-done
    }
    fmt.Println("所有 goroutine 完成！")
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

package main

import (
    "fmt"
    "runtime"
)

// 使用闭包递归，大量函数调用
func main() {
    // 打印初始栈大小（对用户不直接可见，用 GODEBUG 看）
    fmt.Println("程序运行中，goroutine 栈会动态增长...")

    // 创建一个会递归调用的 goroutine
    go deepRecursion(1)

    // 防止主函数退出
    select {}
}

func deepRecursion(n int) {
    if n%1000 == 0 {
        fmt.Printf("递归深度: %d, 当前 goroutine 数量: %d\n", n, runtime.NumGoroutine())
    }
    deepRecursion(n + 1) // 无限递归，栈会不断增长
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

package main

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

func main() {
    var wg sync.WaitGroup

    // 方式1：自然结束
    wg.Add(1)
    go func() {
        defer wg.Done()
        fmt.Println("Goroutine 1: 我正常执行完就退出了～")
    }()

    // 方式2：runtime.Goexit()
    wg.Add(1)
    go func() {
        defer wg.Done()
        fmt.Println("Goroutine 2: 收到退出信号，准备离场...")
        runtime.Goexit() // 立即退出
        fmt.Println("Goroutine 2: 这行不会执行！")
    }()

    // 方式3：panic（只会影响自己，不会传播）
    wg.Add(1)
    go func() {
        defer wg.Done()
        defer func() {
            if r := recover(); r != nil {
                fmt.Printf("Goroutine 3: 捕获到 panic: %v，已恢复！\n", r)
            }
        }()
        fmt.Println("Goroutine 3: 啊，我要 panic 了！")
        panic("炸了炸了！")
    }()

    wg.Wait()
    fmt.Println("主函数：大家都退出了，我也收工！")
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

package main

import (
    "fmt"
    "runtime"
    "time"
)

func main() {
    // 泄漏的 goroutine：往 nil channel 发送，永远阻塞
    leak := func() {
        ch := make(chan int)
        go func() {
            <-ch // 从 nil channel 接收，永远阻塞
        }()
    }

    // 创建一些泄漏的 goroutine
    for i := 0; i < 5; i++ {
        go leak()
    }

    // 观察 goroutine 数量
    fmt.Printf("初始 goroutine 数量: %d\n", runtime.NumGoroutine())

    time.Sleep(2 * time.Second)
    fmt.Printf("2秒后 goroutine 数量: %d（应该有明显增长）\n", runtime.NumGoroutine())

    // 正常应该只有主 goroutine + timer goroutine
    // 但我们创建了泄漏的，这里会显示更多
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

package main

import (
    "context"
    "fmt"
    "time"
)

func main() {
    ctx, cancel := context.WithCancel(context.Background())

    // 启动 goroutine，它会监听 context 取消
    go func() {
        for {
            select {
            case <-ctx.Done():
                fmt.Println("Goroutine: 收到取消信号，优雅退出！")
                return
            default:
                fmt.Println("Goroutine: 工作中...")
                time.Sleep(500 * time.Millisecond)
            }
        }
    }()

    time.Sleep(2 * time.Second)
    fmt.Println("主函数: 够了，让 goroutine 停下来！")
    cancel() // 发送取消信号

    time.Sleep(500 * time.Millisecond)
}

1

ch := make(chan 元素类型, 缓冲区大小)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

package main

import "fmt"

func main() {
    // 无缓冲 channel
    unbuffered := make(chan int)      // 等价于 make(chan int, 0)
    fmt.Printf("无缓冲 channel: %v\n", unbuffered)

    // 有缓冲 channel
    buffered := make(chan string, 3)  // 缓冲区大小为 3
    fmt.Printf("有缓冲 channel: %v\n", buffered)

    // 查看 channel 容量和长度
    fmt.Printf("缓冲 channel 容量: %d\n", cap(buffered))
    fmt.Printf("缓冲 channel 当前长度: %d\n", len(buffered))
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

package main

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

func main() {
    ch := make(chan int) // 无缓冲 channel
    var wg sync.WaitGroup

    // 接收者 goroutine
    wg.Add(1)
    go func() {
        defer wg.Done()
        fmt.Println("接收者: 我准备好了，等待数据...")
        value := <-ch // 阻塞，直到发送者发送
        fmt.Printf("接收者: 收到数据了！值是 %d\n", value)
    }()

    // 发送者 goroutine
    time.Sleep(1 * time.Second) // 故意等一秒，让接收者先跑
    fmt.Println("发送者: 我要发送数据了！")
    ch <- 42 // 阻塞，直到接收者接收
    fmt.Println("发送者: 数据已发送，任务完成！")

    wg.Wait()
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

package main

import (
    "fmt"
    "time"
)

func main() {
    ch := make(chan int, 3) // 缓冲区大小为 3

    // 查看初始状态
    fmt.Printf("容量: %d, 长度: %d\n", cap(ch), len(ch))

    // 发送数据（不阻塞，因为有空位）
    ch <- 1
    ch <- 2
    ch <- 3
    fmt.Printf("发送3个后 - 容量: %d, 长度: %d\n", cap(ch), len(ch))

    // 再发送会阻塞（缓冲区满）
    go func() {
        fmt.Println("Goroutine: 缓冲区有位置了，我进来了！")
        ch <- 4
        fmt.Println("Goroutine: 4 发送成功！")
    }()

    time.Sleep(100 * time.Millisecond) // 让 goroutine 开始执行
    fmt.Println("主函数: 取出一个数据:", <-ch)
    fmt.Printf("取出一个后 - 容量: %d, 长度: %d\n", cap(ch), len(ch))

    time.Sleep(100 * time.Millisecond) // 给 goroutine 机会完成
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

package main

import "fmt"

func main() {
    ch := make(chan string, 2)

    // 发送字符串到 channel
    ch <- "第一封信"
    fmt.Println("主函数: 已发送 '第一封信'")

    ch <- "第二封信"
    fmt.Println("主函数: 已发送 '第二封信'")

    // 缓冲区满了再发送会阻塞（这里会 deadlock，因为没有接收者）
    // ch <- "第三封信" // 如果取消注释，这段代码会 panic
    // fmt.Println("主函数: 已发送 '第三封信'") // 不会执行到

    // 接收数据（释放缓冲区空间）
    msg1 := <-ch
    fmt.Printf("收到: %s\n", msg1)

    msg2 := <-ch
    fmt.Printf("收到: %s\n", msg2)
}

1
2
3
4
5
6
7

package main

func main() {
    ch := make(chan int)
    close(ch)
    ch <- 42 // panic: send on closed channel
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

package main

import (
    "fmt"
    "time"
)

func main() {
    ch := make(chan int, 1)

    // 接收者必须等待发送者（或者有缓冲空间）
    // 这里因为有缓冲，所以发送者不会阻塞

    go func() {
        for i := 1; i <= 3; i++ {
            fmt.Printf("发送者: 发送 %d\n", i)
            ch <- i
            time.Sleep(500 * time.Millisecond)
        }
        close(ch) // 发送完毕后关闭 channel
    }()

    // 接收所有数据
    fmt.Println("接收者: 开始接收...")
    for v := range ch { // 使用 range 遍历，直到 channel 关闭
        fmt.Printf("接收者: 收到 %d\n", v)
    }
    fmt.Println("接收者: channel 已关闭，接收完毕！")
}

1
2
3
4
5
6
7
8

// 方式1：ok-idom，接收值的同时判断 channel 是否关闭
value, ok := <-ch
if !ok {
    fmt.Println("Channel 已关闭")
}

// 方式2：只接收值，不判断
value := <-ch

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

package main

import (
    "fmt"
    "time"
)

func main() {
    ch := make(chan int, 3)

    // 发送一些数据
    ch <- 10
    ch <- 20
    ch <- 30

    // 关闭 channel
    close(ch)
    fmt.Println("Channel 已关闭！")

    // 接收所有剩余数据
    for {
        value, ok := <-ch
        if !ok {
            fmt.Println("接收完成，channel 已关闭，ok = false")
            break
        }
        fmt.Printf("收到: %d\n", value)
    }

    // 关闭后再接收，返回零值和 false
    value, ok := <-ch
    fmt.Printf("关闭后接收 - 值: %d, ok: %v\n", value, ok)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

package main

import (
    "fmt"
    "time"
)

func main() {
    ch := make(chan string, 2)

    // 启动一个 goroutine 发送数据
    go func() {
        messages := []string{"苹果", "香蕉", "橙子", "葡萄"}
        for _, msg := range messages {
            fmt.Printf("发送: %s\n", msg)
            ch <- msg
            time.Sleep(300 * time.Millisecond)
        }
        close(ch) // 发送完毕，关闭 channel
        fmt.Println("发送者: 数据发送完毕，channel 已关闭！")
    }()

    // 使用 range 接收，自动阻塞直到 channel 关闭
    fmt.Println("接收者: 开始接收...")
    for msg := range ch {
        fmt.Printf("收到: %s\n", msg)
    }
    fmt.Println("接收者: 接收完毕！")
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

// range 写法（简洁）
for v := range ch {
    fmt.Println(v)
}

// 等价的传统写法
for {
    v, ok := <-ch
    if !ok {
        break
    }
    fmt.Println(v)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

package main

import "fmt"

// producer 只发送，不能接收
func producer(ch chan<- int) {
    for i := 1; i <= 3; i++ {
        fmt.Printf("生产者: 发送 %d\n", i)
        ch <- i // 合法：发送
        // v := <-ch // 非法：编译错误
    }
}

// consumer 只接收，不能发送
func consumer(ch <-chan int) {
    for {
        v, ok := <-ch // 合法：接收
        if !ok {
            fmt.Println("消费者: channel 已关闭，退出")
            return
        }
        fmt.Printf("消费者: 收到 %d\n", v)
    }
}

func main() {
    ch := make(chan int, 2)

    go producer(ch)
    go consumer(ch)

    // 阻塞等待
    select {}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

package main

import (
    "fmt"
    "time"
)

func main() {
    var nilCh chan int // 默认是 nil

    fmt.Println("nil channel:", nilCh)

    // 尝试从 nil channel 接收（永久阻塞）
    go func() {
        fmt.Println("Goroutine: 尝试从 nil channel 接收...")
        v := <-nilCh // 永久阻塞，永远不会执行到这里
        fmt.Println("Goroutine: 收到:", v) // 不会打印
    }()

    // 尝试向 nil channel 发送（永久阻塞）
    go func() {
        fmt.Println("Goroutine: 尝试向 nil channel 发送...")
        nilCh <- 42 // 永久阻塞，永远不会执行到这里
        fmt.Println("Goroutine: 发送成功") // 不会打印
    }()

    // select 也会跳过 nil channel
    go func() {
        select {
        case v := <-nilCh:
            fmt.Println("收到:", v) // 永远不会执行
        case <-time.After(1 * time.Second):
            fmt.Println("1秒后检测：nil channel 仍然阻塞！")
        }
    }()

    time.Sleep(2 * time.Second)
    fmt.Println("主函数: 程序结束")
}

1
2

var ch chan int // ch == nil
ch = make(chan int) // ch != nil

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

package main

import (
    "fmt"
    "time"
)

func main() {
    ch1 := make(chan string, 1)
    ch2 := make(chan string, 1)

    // 启动两个 goroutine
    go func() {
        time.Sleep(1 * time.Second)
        ch1 <- "来自通道1的消息"
    }()

    go func() {
        time.Sleep(2 * time.Second)
        ch2 <- "来自通道2的消息"
    }()

    // select 监听两个 channel
    for i := 0; i < 2; i++ {
        select {
        case msg1 := <-ch1:
            fmt.Println("收到:", msg1)
        case msg2 := <-ch2:
            fmt.Println("收到:", msg2)
        case <-time.After(3 * time.Second):
            fmt.Println("超时！")
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

package main

import (
    "fmt"
    "sync"
)

func main() {
    // 两个 channel，都已经就绪（有数据）
    ch1 := make(chan int, 1)
    ch2 := make(chan int, 1)

    ch1 <- 1
    ch2 <- 2

    // 统计两个 case 被选中的次数
    count1, count2 := 0, 0
    iterations := 10000

    for i := 0; i < iterations; i++ {
        select {
        case <-ch1:
            count1++
            ch1 <- 1 // 再次放入数据，保持就绪状态
        case <-ch2:
            count2++
            ch2 <- 2 // 再次放入数据，保持就绪状态
        }
    }

    fmt.Printf("case1 被选中: %d 次\n", count1)
    fmt.Printf("case2 被选中: %d 次\n", count2)
    fmt.Printf("比例接近 1:1（随机公平）\n")
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

package main

import (
    "fmt"
    "time"
)

func main() {
    ch := make(chan int, 1)

    // channel 目前是空的
    fmt.Println("=== 非阻塞接收 ===")

    // 没有 default，select 会阻塞等待
    // select {
    // case v := <-ch:
    //     fmt.Println("收到:", v)
    // }

    // 有 default，立即执行
    select {
    case v := <-ch:
        fmt.Println("收到:", v)
    default:
        fmt.Println("通道暂时没有数据，执行 default 分支！")
    }

    // 放入数据
    ch <- 42
    fmt.Println("\n=== 放入数据后再试 ===")

    select {
    case v := <-ch:
        fmt.Println("收到:", v)
    default:
        fmt.Println("通道暂时没有数据，执行 default 分支！")
    }

    // 模拟非阻塞轮询
    fmt.Println("\n=== 非阻塞轮询 ===")
    for i := 0; i < 5; i++ {
        select {
        case v := <-ch:
            fmt.Printf("第 %d 次轮询: 收到 %d\n", i, v)
            ch <- i * 10 // 继续放入数据
        default:
            fmt.Printf("第 %d 次轮询: 暂无数据\n", i)
        }
        time.Sleep(100 * time.Millisecond)
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

package main

import (
    "fmt"
    "time"
)

func main() {
    ch1 := make(chan int, 1)
    var nilCh chan int // nil channel

    ch1 <- 100

    fmt.Println("=== 测试 nil channel 在 select 中的行为 ===")

    select {
    case v := <-ch1:
        fmt.Println("收到 ch1 的数据:", v)
    case <-nilCh:
        // 这个 case 永远不会被选中！
        fmt.Println("收到 nil channel 的数据")
    case v := <-ch1: // 同一个 channel 可以有多个 case
        fmt.Println("另一个 ch1 case:", v)
    default:
        fmt.Println("所有 channel 都不可用，执行 default")
    }

    // nil channel case 被静默跳过
    fmt.Println("\n=== nil channel case 被跳过 ===")
    go func() {
        for i := 0; i < 5; i++ {
            select {
            case v := <-ch1:
                fmt.Printf("收到 ch1: %d\n", v)
            case <-nilCh: // 永远不会就绪，被跳过
                fmt.Println("nil channel")
            case <-time.After(500 * time.Millisecond):
                fmt.Println("超时...")
                return
            }
            time.Sleep(200 * time.Millisecond)
        }
    }()

    time.Sleep(2 * time.Second)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

package main

import (
    "context"
    "fmt"
    "time"
)

func main() {
    // 模拟一个慢请求
    slowTask := func() chan string {
        ch := make(chan string, 1)
        go func() {
            time.Sleep(3 * time.Second) // 模拟耗时操作
            ch <- "任务完成"
        }()
        return ch
    }

    // 方式1：使用 time.After 实现超时
    fmt.Println("=== 方式1: time.After 超时 ===")
    ch1 := slowTask()
    select {
    case result := <-ch1:
        fmt.Println("收到结果:", result)
    case <-time.After(2 * time.Second):
        fmt.Println("超时了！（2秒）")
    }

    // 方式2：使用 context 实现超时
    fmt.Println("\n=== 方式2: context 超时 ===")
    ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
    defer cancel()

    ch2 := make(chan string, 1)
    go func() {
        time.Sleep(3 * time.Second)
        ch2 <- "任务完成"
    }()

    select {
    case result := <-ch2:
        fmt.Println("收到结果:", result)
    case <-ctx.Done():
        fmt.Println("超时！（ctx）")
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

package main

import "fmt"

func main() {
    fmt.Println("=== 单 goroutine 死锁 ===")
    ch := make(chan int)
    <-ch // 主 goroutine 从空 channel 接收，永久阻塞
    fmt.Println("不会执行到这里")
}

1
2
3
4
5
6

package main

func main() {
    ch := make(chan int)
    ch <- 1 // 往无缓冲 channel 发送，没有接收者，永久阻塞
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

package main

import (
    "context"
    "fmt"
    "time"
)

func main() {
    ctx, cancel := context.WithCancel(context.Background())
    dataCh := make(chan int, 1)
    quitCh := make(chan struct{})

    // 模拟数据生产者
    go func() {
        for i := 1; i <= 5; i++ {
            time.Sleep(300 * time.Millisecond)
            select {
            case <-ctx.Done():
                fmt.Println("生产者: context 取消，退出")
                return
            case dataCh <- i:
                fmt.Printf("生产者: 发送数据 %d\n", i)
            }
        }
        close(quitCh)
    }()

    // for-select 模式：监听多个 channel
    fmt.Println("消费者: 开始监听...")
    for {
        select {
        case v := <-dataCh:
            fmt.Printf("消费者: 收到数据 %d\n", v)
        case <-quitCh:
            fmt.Println("消费者: quitCh 关闭，退出循环")
            return
        }
    }

    cancel()
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

package main

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

func main() {
    // 任务队列
    jobs := make(chan int, 10)
    results := make(chan int, 10)

    // 启动 3 个消费者
    var wg sync.WaitGroup
    for w := 1; w <= 3; w++ {
        wg.Add(1)
        go consumer(w, jobs, results, &wg)
    }

    // 启动 2 个生产者
    for p := 1; p <= 2; p++ {
        go producer(p, jobs)
    }

    // 启动一个收集结果的 goroutine
    go func() {
        wg.Wait()
        close(results)
    }()

    // 打印结果
    for result := range results {
        fmt.Printf("最终结果: %d\n", result)
    }

    close(jobs)
    time.Sleep(500 * time.Millisecond)
    fmt.Println("主函数: 全部完成！")
}

func producer(id int, jobs chan<- int) {
    for j := 1; j <= 3; j++ {
        task := id*100 + j
        fmt.Printf("生产者 %d: 生产任务 %d\n", id, task)
        jobs <- task
    }
}

func consumer(id int, jobs <-chan int, results chan<- int, wg *sync.WaitGroup) {
    defer wg.Done()
    for job := range jobs {
        // 模拟处理
        time.Sleep(100 * time.Millisecond)
        result := job * 2
        fmt.Printf("消费者 %d: 处理任务 %d -> 结果 %d\n", id, job, result)
        results <- result
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

package main

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

func main() {
    tasks := make(chan int, 10)
    results := make(chan int, 10)

    // 启动多个 worker（fan-out）
    numWorkers := 4
    var wg sync.WaitGroup

    fmt.Printf("启动 %d 个 worker...\n", numWorkers)
    for w := 1; w <= numWorkers; w++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            for task := range tasks {
                // 模拟耗时处理
                time.Sleep(100 * time.Millisecond)
                result := task * task
                fmt.Printf("Worker %d: 处理任务 %d -> 结果 %d\n", id, task, result)
                results <- result
            }
            fmt.Printf("Worker %d: 任务队列已空，退出\n", id)
        }(w)
    }

    // 发送任务
    go func() {
        for i := 1; i <= 8; i++ {
            tasks <- i
            fmt.Printf("主函数: 发送任务 %d\n", i)
        }
        close(tasks)
    }()

    // 收集结果
    go func() {
        wg.Wait()
        close(results)
    }()

    count := 0
    for result := range results {
        fmt.Printf("收到结果: %d\n", result)
        count++
    }

    fmt.Printf("共收到 %d 个结果\n", count)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

package main

import (
    "fmt"
    "time"
)

// Pipeline 三个阶段
func generate(nums ...int) <-chan int {
    out := make(chan int)
    go func() {
        for _, n := range nums {
            out <- n
        }
        close(out)
    }()
    return out
}

func square(in <-chan int) <-chan int {
    out := make(chan int)
    go func() {
        for n := range in {
            out <- n * n
        }
        close(out)
    }()
    return out
}

func double(in <-chan int) <-chan int {
    out := make(chan int)
    go func() {
        for n := range in {
            out <- n * 2
        }
        close(out)
    }()
    return out
}

func main() {
    // 构建 pipeline: generate -> square -> double -> square
    pipeline := double(square(generate(1, 2, 3, 4, 5)))

    fmt.Println("Pipeline 处理结果:")
    for v := range pipeline {
        fmt.Printf("%d ", v)
        time.Sleep(100 * time.Millisecond) // 模拟处理时间
    }
    fmt.Println("\nPipeline 完成！")
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

package main

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

func worker(ctx context.Context, id int, wg *sync.WaitGroup) {
    defer wg.Done()
    for {
        select {
        case <-ctx.Done():
            fmt.Printf("Worker %d: 收到取消信号，优雅退出（reason: %s）\n", id, ctx.Err())
            return
        default:
            fmt.Printf("Worker %d: 工作中...\n", id)
            time.Sleep(200 * time.Millisecond)
        }
    }
}

func main() {
    ctx, cancel := context.WithCancel(context.Background())

    var wg sync.WaitGroup
    for i := 1; i <= 3; i++ {
        wg.Add(1)
        go worker(ctx, i, &wg)
    }

    time.Sleep(1 * time.Second)
    fmt.Println("主函数: 发送取消信号！")
    cancel() // 取消所有 worker

    wg.Wait()
    fmt.Println("主函数: 所有 worker 已退出！")
}