深入理解Go语言中select{}的行为与高效并发模式

func main() {
    // ... 前面部分代码 ...
    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"
    "time"
)

// runTask 模拟一个需要处理时间的任务
func runTask(t string, ch chan bool, wg *sync.WaitGroup) {
    defer wg.Done() // 确保任务完成后递减 WaitGroup 计数器
    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                        // 用于等待所有任务完成

    fmt.Println("Starting task scheduling...")
    for _, f := range files {
        activeWorkers <- true // 尝试向通道发送值，如果通道已满，则阻塞，直到有槽位释放
        wg.Add(1)             // 为每个启动的任务增加 WaitGroup 计数器
        fmt.Printf("activeWorkers 队列长度: %d. 启动任务: %s\n", len(activeWorkers), f)
        go runTask(f, activeWorkers, &wg) // 启动任务 goroutine
    }

    wg.Wait() // 阻塞主 goroutine，直到所有任务都调用了 wg.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 协程从输入通道接收任务，处理后将结果发送到输出通道
func worker(in chan string, out chan string) {
    for task := range in { // 循环从输入通道接收任务，通道关闭时循环结束
        result := runTask(task)
        out <- result // 将任务结果发送到输出通道
    }
}

func main() {
    numWorkers := 3 // 工作协程的数量，控制并发度

    // 创建输入通道和输出通道
    in := make(chan string)  // 用于提交任务
    out := make(chan string) // 用于收集结果

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

    files := []string{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j"}

    // 启动一个goroutine来提交所有任务
    go func() {
        for _, f := range files {
            in <- f // 提交任务到输入通道
        }
        close(in) // 所有任务提交完毕后，关闭输入通道，通知worker协程
    }()

    // 主goroutine从输出通道收集所有任务的结果
    // 循环次数等于任务总数，确保收集所有结果
    for i := 0; i < len(files); i++ {
        result := <-out // 阻塞等待并接收一个任务结果
        fmt.Printf("Received result for task: %s\n", result)
    }

    // 此时，所有任务都已处理完毕，并且所有结果都已收集
    fmt.Println("所有任务已处理并收集结果。程序即将退出。")
}