Go Academy · 课时

启动 Goroutine

go 关键字、Goroutine 生命周期与 WaitGroups

启动 Goroutine 是 CoddyKit 上的免费 Go Academy 课时。这是第 1 节课，共 4 节。你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。这是 Go Academy 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 Go Academy 课程共包含 4 节课。

什么是 goroutine

goroutine是由 Go 运行时管理的轻量级并发执行函数。goroutine 的开销远低于 OS 线程，因此您可以运行数千个 goroutine：

使用go关键字启动
初始栈约为 2KB（会动态增长）
由 Go 运行时而不是 OS 进行调度
通过通道而不是共享内存进行通信

go 关键字

在任意函数调用前加上go，即可将其作为 goroutine 启动：

package main
import ("fmt"; "time")

func greet(name string) {
    fmt.Printf("Hello, %s!\n", name)
}

func main() {
    go greet("Alice")   // runs concurrently
    go greet("Bob")     // runs concurrently
    time.Sleep(100 * time.Millisecond) // wait for goroutines
    fmt.Println("done")
}

goroutine 生命周期

goroutine 在执行go语句时启动，在其函数返回时退出。如果main返回，所有 goroutine 都会被终止：

package main
import ("fmt"; "time")

func worker(id int) {
    fmt.Printf("Worker %d starting\n", id)
    time.Sleep(time.Duration(id) * 50 * time.Millisecond)
    fmt.Printf("Worker %d done\n", id)
}

func main() {
    for i := 1; i <= 3; i++ {
        go worker(i)
    }
    time.Sleep(300 * time.Millisecond) // naive wait
}

使用 sync.WaitGroup 进行协调

请使用sync.WaitGroup等待 goroutine 完成，而不要使用休眠：

package main
import ("fmt"; "sync")

func worker(id int, wg *sync.WaitGroup) {
    defer wg.Done()  // signal completion
    fmt.Printf("Worker %d working\n", id)
}

func main() {
    var wg sync.WaitGroup
    for i := 1; i <= 5; i++ {
        wg.Add(1)           // register one goroutine
        go worker(i, &wg)
    }
    wg.Wait()               // block until all Done()
    fmt.Println("all workers finished")
}

匿名 goroutine

直接将匿名函数作为 goroutine 启动，适用于内联并发任务：

package main
import ("fmt"; "sync")

func main() {
    var wg sync.WaitGroup
    for i := 0; i < 3; i++ {
        i := i  // capture loop variable
        wg.Add(1)
        go func() {
            defer wg.Done()
            fmt.Printf("goroutine %d\n", i)
        }()
    }
    wg.Wait()
}

循环变量捕获陷阱

如果不捕获循环变量，所有 goroutine 可能会看到同一个（最终）值，这是 Go 中一种典型的并发错误：

package main
import ("fmt"; "sync")

func main() {
    var wg sync.WaitGroup
    for i := 0; i < 3; i++ {
        wg.Add(1)
        go func(n int) {  // pass i as argument — safe
            defer wg.Done()
            fmt.Println(n)  // prints 0, 1, 2 in some order
        }(i)
    }
    wg.Wait()
}

goroutine 与线程

优先使用 goroutine 而不是 OS 线程的原因：

初始栈为 2KB，而 OS 线程约为 1MB
创建耗时为微秒级，而不是毫秒级
Go 运行时会将 goroutine 多路复用到由 GOMAXPROCS 指定数量的 OS 线程上
goroutine 切换是协作式的，不涉及内核
Go 会处理调度，您可以专注于逻辑

GOMAXPROCS

runtime.GOMAXPROCS控制并行运行 goroutine 的 OS 线程数量（默认为处理器数量）：

package main
import ("fmt"; "runtime")

func main() {
    // Default: number of available CPU cores
    fmt.Println("CPUs:", runtime.NumCPU())
    fmt.Println("GOMAXPROCS:", runtime.GOMAXPROCS(0)) // 0 = query without changing

    // Set to 1 for debugging race conditions:
    // runtime.GOMAXPROCS(1)

    fmt.Println("Goroutines:", runtime.NumGoroutine())
}

goroutine 泄漏

当 goroutine 启动后却永不退出时，就会发生 goroutine 泄漏。常见原因包括：通道接收被阻塞、互斥锁被阻塞以及没有取消机制：

package main
import ("fmt"; "time"; "runtime")

func leaky() {
    ch := make(chan int)  // nobody sends to ch
    go func() {
        v := <-ch  // blocks forever — goroutine leaked!
        fmt.Println(v)
    }()
}

func main() {
    leaky()
    time.Sleep(10 * time.Millisecond)
    fmt.Println("goroutines:", runtime.NumGoroutine()) // > 1
}

goroutine 最佳实践

goroutine 使用指南：

始终明确 goroutine 将如何退出
使用 WaitGroup 或通道进行同步，而不要使用休眠
将循环变量作为函数参数传递，而不要通过闭包传递
使用上下文取消 goroutine，不要让它们持续运行
使用竞态检测器：go run -race main.go

快速检查

在 goroutine 中，避免循环变量捕获错误的正确方法是什么？

回顾：启动 goroutine

摘要：

使用go fn()启动——轻量且开销低
使用sync.WaitGroup等待：Add(1)、defer Done()、Wait()
通过参数或重新声明来捕获循环变量
始终明确每个 goroutine 如何退出，以防止泄漏
使用-race标志检测数据竞争

常见问题解答

「启动 Goroutine」课时是免费的吗？

是的 — 「启动 Goroutine」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Go Academy 课程的其余内容，请升级到 CoddyKit PRO。 Go Academy 课程共包含 4 节课。

「启动 Goroutine」这节课中我会学到什么？

go 关键字、Goroutine 生命周期与 WaitGroups 你通过在浏览器中直接运行的动手代码来练习 Go Academy，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 Go Academy 需要有经验吗？

无需任何先前经验。CoddyKit 上的 Go Academy 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。这是第 1 节课，共 4 节。

「启动 Goroutine」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 Go Academy 课中编写并运行代码吗？

能。每节 Go Academy 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

← 返回 Go Academy