面试必问：Go并发中for range与Channel的正确用法，你真的清楚吗？

ticketCount := 100

// 1000个goroutine同时执行：
if ticketCount > 0 {
    ticketCount--  // 不加锁会导致数据竞争
}

sum := 0
for _, num := range numbers {
    go func(n int) {
        sum += n  // 不加锁，结果不可预测
    }(num)
}

func sumWithChannel(numbers []int) int {
    ch := make(chanint)
    var wg sync.WaitGroup
    
    // 启动所有计算goroutine
    for _, num := range numbers {
        wg.Add(1)
        gofunc(n int) {
            defer wg.Done()
            ch <- n  // 每个goroutine只发送自己的结果
        }(num)
    }
    
    // 启动一个goroutine在完成后关闭channel
    gofunc() {
        wg.Wait()
        close(ch)  // 所有发送完成后安全关闭通道
    }()
    
    // 主goroutine负责收集结果
    sum := 0
    for n := range ch {  // 自动循环直到channel关闭
        sum += n
    }
    return sum
}

package main

import (
    "fmt"
    "sync"
)

func main() {
    numbers := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
    
    // 方案一：使用锁（传统共享内存方式）
    var mu sync.Mutex
    sum1 := 0
    var wg1 sync.WaitGroup
    
    for _, n := range numbers {
        wg1.Add(1)
        gofunc(x int) {
            defer wg1.Done()
            mu.Lock()
            sum1 += x
            mu.Unlock()
        }(n)
    }
    wg1.Wait()
    fmt.Println("加锁求和:", sum1)  // 输出: 55
    
    // 方案二：使用Channel（推荐方式）
    sum2 := sumWithChannel(numbers)
    fmt.Println("Channel求和:", sum2)  // 输出: 55
    
    // 方案三：Worker Pool模式（处理大量数据时更高效）
    sum3 := sumWithWorkerPool(numbers, 3)  // 使用3个worker
    fmt.Println("Worker Pool求和:", sum3)  // 输出: 55
}

func sumWithWorkerPool(numbers []int, workerCount int) int {
    tasks := make(chanint, len(numbers))
    results := make(chanint, len(numbers))
    var wg sync.WaitGroup
    
    // 启动worker
    for i := 0; i < workerCount; i++ {
        wg.Add(1)
        gofunc() {
            defer wg.Done()
            for n := range tasks {
                results <- n  // 实际场景中这里可能有更复杂的计算
            }
        }()
    }
    
    // 发送任务
    for _, n := range numbers {
        tasks <- n
    }
    close(tasks)
    
    // 等待所有worker完成
    gofunc() {
        wg.Wait()
        close(results)
    }()
    
    // 收集结果
    sum := 0
    for n := range results {
        sum += n
    }
    return sum
}

// 1. 遍历切片/数组/映射
for i, v := range slice {
    // i是索引，v是值副本
    // 循环次数在开始时确定
}

// 2. 从Channel接收值
for value := range ch {
    // 不断从ch接收值，直到channel被关闭
    // 如果ch未被关闭，这里会永久阻塞
}

是否需要共享状态？
    ├── 否 → 使用Channel传递数据
    └── 是 → 是否可以拆分为独立任务？
              ├── 是 → 使用Channel + 结果合并
              └── 否 → 使用锁保护共享状态