Go并发：理解select{}的非阻塞行为与避免死锁的策略

package main

import (
    "fmt"
    "math/rand"
    "time"
)

func runTask(t string, ch *chan bool) {
    start := time.Now()
    fmt.Println("starting task", t)
    time.Sleep(time.Millisecond * time.Duration(rand.Int31n(1500))) // 模拟处理时间
    fmt.Println("done running task", t, "in", time.Since(start))
    <-*ch // 任务完成后，释放一个信号量
}

func main() {
    numWorkers := 3
    files := []string{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j"}

    activeWorkers := make(chan bool, numWorkers) // 容量为numWorkers的缓冲通道作为信号量

    for _, f := range files {
        activeWorkers <- true // 尝试获取一个信号量，如果通道已满则阻塞
        fmt.Printf("activeWorkers is %d long.\n", len(activeWorkers))
        go runTask(f, &activeWorkers)
    }
    select{} // 期望阻塞主Goroutine，等待所有任务完成
}

package main

import (
    "fmt"
    "math/rand"
    "sync" // 引入sync包
    "time"
)

func runTaskWithWaitGroup(t string, ch chan bool, wg *sync.WaitGroup) {
    defer wg.Done() // 确保Goroutine完成时调用Done()
    start := time.Now()
    fmt.Println("starting task", t)
    time.Sleep(time.Millisecond * time.Duration(rand.Int31n(1500))) // 模拟处理时间
    fmt.Println("done running task", t, "in", time.Since(start))
    <-ch // 任务完成后，释放一个信号量
}

func main() {
    numWorkers := 3
    files := []string{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j"}

    activeWorkers := make(chan bool, numWorkers) // 缓冲通道作为信号量
    var wg sync.WaitGroup                        // 声明WaitGroup

    for _, f := range files {
        activeWorkers <- true // 获取一个信号量，控制并发数
        wg.Add(1)             // 每启动一个Goroutine，计数器加1
        fmt.Printf("activeWorkers is %d long.\n", len(activeWorkers))
        go runTaskWithWaitGroup(f, activeWorkers, &wg)
    }

    wg.Wait() // 阻塞主Goroutine，直到所有Goroutine都调用Done()
    fmt.Println("所有任务已完成。")
}

package main

import (
    "fmt"
    "math/rand"
    "time"
)

// runTask 模拟任务执行，返回任务名称
func runTask(t string) string {
    start := time.Now()
    fmt.Println("starting task", t)
    time.Sleep(time.Millisecond * time.Duration(rand.Int31n(1500))) // 模拟处理时间
    fmt.Println("done running task", t, "in", time.Since(start))
    return t // 返回任务结果
}

// worker Goroutine从in通道接收任务，处理后将结果发送到out通道
func worker(in chan string, out chan string) {
    for t := range in { // 循环从in通道接收任务，直到in通道关闭
        out <- runTask(t) // 处理任务并将结果发送到out通道
    }
}

func main() {
    numWorkers := 3
    files := []string{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j"}

    // 创建输入和输出通道
    in, out := make(chan string), make(chan string)

    // 启动固定数量的工作Goroutine
    for i := 0; i < numWorkers; i++ {
        go worker(in, out)
    }

    // 启动一个Goroutine来调度任务（将任务发送到in通道）
    go func() {
        for _, f := range files {
            in <- f // 发送任务
        }
        close(in) // 所有任务发送完毕后，关闭in通道，通知worker Goroutine停止接收
    }()

    // 主Goroutine从out通道接收所有任务的结果
    // 循环次数等于任务总数，确保接收所有结果
    for i := 0; i < len(files); i++ {
        <-out // 接收结果
    }
    // 此时，所有任务都已处理并接收了结果，可以安全退出
    fmt.Println("所有任务已完成并收集到结果。")
}