GO语言基础教程（144）Go goroutine之为普通函数创建goroutine：Go语言goroutine魔法：让普通函数‘分身’执行，轻松搞定并发编程！-优快云博客

一、为什么你需要goroutine这个“并发外挂”？

想象一下：你正在一边煮泡面，一边回微信，同时还在追新番——这就是人类大脑的“多任务处理”。但传统编程中，让一个程序“同时”干多件事，简直能让程序员秃头。

C++或Java的多线程，像是雇一群正式工：工资高（内存占用大）、入职手续复杂（创建销毁开销大）、还得小心管理（易出错）。而Go语言的goroutine，更像是招了一堆“兼职小哥”：随用随招、几乎零成本、干完自动走人，还能同时管理成千上万人！

goroutine的核心优势：

超轻量：初始栈仅2KB，而线程通常要2MB
智能调度：Go运行时自动在线程上调度协程，无需程序员操心
语法简单：只需一个go关键字，普通函数秒变并发任务

二、goroutine底层揭秘：它凭什么这么“轻”？

1. 调度器：Go并发的“超级大脑”
Go自带一个M:N调度器，把M个goroutine映射到N个系统线程上。当某个goroutine遇到阻塞（比如等用户输入），调度器会立刻把其他goroutine挪到空闲线程执行，确保CPU永远在干活。

2. 偷窃式调度：不让任何一个CPU核心偷懒
如果一个线程上的goroutine都跑完了，它的调度器会“偷”其他线程还没处理的goroutine来执行。这种负载均衡机制，让并发效率直接拉满。

3. 快速启动：比线程快10-100倍
创建goroutine基本就是内存分配+注册到调度器，而创建线程需要向操作系统申请资源，流程冗长。

三、实战：把普通函数变成“并发战士”

基础语法简单到哭：

go functionName(args)

Before：一个慢吞吞的串行程序

package main

import (
    "fmt"
    "time"
)

// 模拟一个耗时任务
func doWork(taskID int) {
    fmt.Printf("任务[%d]开始\n", taskID)
    time.Sleep(1 * time.Second) // 模拟耗时操作
    fmt.Printf("任务[%d]完成\n", taskID)
}

func main() {
    start := time.Now()
    
    // 串行执行，慢到让人抓狂
    for i := 1; i <= 3; i++ {
        doWork(i)
    }
    
    fmt.Printf("总耗时: %v\n", time.Since(start))
    // 输出：总耗时: 约3秒
}

After：goroutine并发加速版

package main

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

func doWork(taskID int, wg *sync.WaitGroup) {
    defer wg.Done() // 任务完成时通知WaitGroup
    
    fmt.Printf("任务[%d]开始\n", taskID)
    time.Sleep(1 * time.Second)
    fmt.Printf("任务[%d]完成\n", taskID)
}

func main() {
    start := time.Now()
    var wg sync.WaitGroup
    
    for i := 1; i <= 3; i++ {
        wg.Add(1) // 每启动一个任务就+1
        go doWork(i, &wg) // 关键：加上go关键字
    }
    
    wg.Wait() // 等待所有任务完成
    fmt.Printf("总耗时: %v\n", time.Since(start))
    // 输出：总耗时: 约1秒！
}

运行这个代码，你会看到：
三个任务几乎同时开始，总时间从3秒缩短到1秒！这就是并发的魔力。

四、避坑指南：goroutine常见雷区

坑1：主程序提前退出了，goroutine还没干完活

// 错误示范
func main() {
    go doWork(1)
    // 主函数直接退出，doWork可能根本没执行
}

// 正确做法：用WaitGroup同步
var wg sync.WaitGroup
wg.Add(1)
go func() {
    defer wg.Done()
    doWork(1)
}()
wg.Wait()

坑2：闭包捕获循环变量——经典bug！

for i := 1; i <= 3; i++ {
    wg.Add(1)
    go func() {
        defer wg.Done()
        fmt.Printf("处理任务 %d\n", i) // 坑：所有goroutine都读到循环结束后的i值！
    }()
}

// 修复：传参或创建副本
for i := 1; i <= 3; i++ {
    wg.Add(1)
    go func(taskID int) { // 值传递创建副本
        defer wg.Done()
        fmt.Printf("处理任务 %d\n", taskID) // 正确
    }(i) // 把当前i值传入
}

坑3：忘记处理panic——goroutine崩溃会拖累整个程序

go func() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("捕获到panic:", r)
        }
    }()
    // 可能panic的代码
    riskyOperation()
}()

五、高级技巧：goroutine实战模式

模式1：限流并发——别把系统搞崩了

// 用带缓冲的channel控制并发数
concurrencyLimit := make(chan struct{}, 10) // 最多同时10个goroutine

for i := 0; i < 100; i++ {
    wg.Add(1)
    concurrencyLimit <- struct{}{} // 获取信号量
    
    go func(taskID int) {
        defer wg.Done()
        defer func() { <-concurrencyLimit }() // 释放信号量
        
        doWork(taskID)
    }(i)
}

模式2：超时控制——不给慢任务磨洋工的机会

resultChan := make(chan string, 1)

go func() {
    // 模拟不确定耗时的任务
    time.Sleep(3 * time.Second)
    resultChan <- "任务完成"
}()

select {
case result := <-resultChan:
    fmt.Println(result)
case <-time.After(2 * time.Second): // 2秒超时
    fmt.Println("任务超时！")
}

六、完整示例：并发下载管理器

下面这个例子综合运用了各种goroutine技巧：

package main

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

// 模拟文件下载
func downloadFile(filename string, wg *sync.WaitGroup, limit chan struct{}) {
    defer wg.Done()
    defer func() { <-limit }() // 释放并发许可
    
    fmt.Printf("开始下载: %s\n", filename)
    downloadTime := time.Duration(rand.Intn(3)+1) * time.Second
    time.Sleep(downloadTime) // 模拟下载耗时
    
    fmt.Printf("下载完成: %s (耗时%v)\n", filename, downloadTime)
}

func main() {
    rand.Seed(time.Now().UnixNano())
    
    files := []string{"电影.mp4", "文档.pdf", "音乐.mp3", "图片.jpg", "软件.zip"}
    var wg sync.WaitGroup
    concurrentLimit := make(chan struct{}, 2) // 最多同时下载2个文件
    
    start := time.Now()
    
    for _, file := range files {
        wg.Add(1)
        concurrentLimit <- struct{}{} // 获取并发许可
        go downloadFile(file, &wg, concurrentLimit)
    }
    
    wg.Wait()
    fmt.Printf("\n所有下载完成! 总耗时: %v\n", time.Since(start))
}

运行效果：