Golang 并发编程入门：Goroutine 简介与基础用法

一、什么是 Goroutine？

Goroutine 是 Golang 中的一种轻量级线程，用于实现并发操作。与传统线程相比，Goroutine 的优势在于它具有更低的资源消耗和更高的效率。每个 Goroutine 在运行时被 Go 的调度器（Scheduler）管理，并且它们共享内存空间。这使得在单个系统线程上运行成千上万个 Goroutine 成为可能。

1、Goroutine 的特点：

1. 轻量级：内存开销非常小，大约只需 2KB。
2. 非抢占式调度：Goroutine 自愿让出 CPU，通过协作完成任务切换。
3. 并发与并行：Goroutine 提供并发模型，多个任务可以同时进行。
4. 阻塞模型简化开发：避免了复杂的回调函数，使代码结构更加简洁。

二、如何启动 Goroutine

要启动 Goroutine，我们只需要在函数调用前加上 go 关键字。此操作会将该函数在单独的 Goroutine 中异步执行，主程序不会等待它完成。

语法：

go 函数名(参数)

示例 1：基本的 Goroutine 用法

package main

import (
    "fmt"
    "time"
)

func printMessage() {
    fmt.Println("Goroutine is running!")
}

func main() {
    go printMessage() // 启动 Goroutine
    time.Sleep(1 * time.Second) // 暂停主线程，确保 Goroutine 执行完
    fmt.Println("Main function is done.")
}

输出：

Goroutine is running!  
Main function is done.

解释：

• 主 Goroutine（即 main 函数）立即启动了一个子 Goroutine 来运行 printMessage 函数。
• 如果没有 time.Sleep，主 Goroutine 可能会在子 Goroutine 还未执行时结束，导致没有输出。

三、主 Goroutine 与子 Goroutine 的关系

1. 主 Goroutine：main 函数所在的 Goroutine，程序从这里开始运行。
2. 子 Goroutine：由主 Goroutine 或其他 Goroutine 创建的 Goroutine。

关键点：如果主 Goroutine 结束，所有未完成的子 Goroutine 也会被强制终止。

示例 2：主线程结束导致子 Goroutine 终止

package main

import (
    "fmt"
    "time"
)

func main() {
    go func() {
        time.Sleep(2 * time.Second)
        fmt.Println("This message may never appear.")
    }()

    fmt.Println("Main function is done.")
    // 主 Goroutine 立即结束，子 Goroutine 没有机会完成
}

输出：

Main function is done.

解释：

• 主 Goroutine 结束时，所有未完成的子 Goroutine 会立即停止，因此不会看到子 Goroutine 的输出。

四、Goroutine 的参数传递

在 Golang 中，Goroutine 支持传递参数，但需要注意是按值传递，而不是按引用。

示例 3：Goroutine 传递参数

package main

import (
    "fmt"
)

func printNumber(num int) {
    fmt.Println("Number:", num)
}

func main() {
    for i := 1; i <= 3; i++ {
        go printNumber(i) // 启动 Goroutine 传递参数
    }

    fmt.Scanln() // 等待用户输入，防止程序提前结束
}

输出（可能）：

Number: 1  
Number: 2  
Number: 3

五、匿名函数中的变量捕获问题

Goroutine 常与匿名函数一起使用，但要小心变量捕获问题。在循环中启动 Goroutine 时，匿名函数可能捕获的不是当前迭代变量的值，而是循环结束后的变量。

示例 4：错误的变量捕获

package main

import (
    "fmt"
    "time"
)

func main() {
    for i := 1; i <= 3; i++ {
        go func() {
            fmt.Println(i) // 捕获的可能是循环结束后的 i
        }()
    }
    time.Sleep(1 * time.Second)
}

输出：

4  
4  
4

修改后的代码：将变量作为参数传递

go func(n int) {
    fmt.Println(n)
}(i)

六、使用 WaitGroup 等待 Goroutine 完成

time.Sleep 不是等待 Goroutine 完成的最佳方式。Go 提供了 sync.WaitGroup 来管理多个 Goroutine 的同步。

示例 5：使用 WaitGroup

package main

import (
    "fmt"
    "sync"
)

func printMessage(msg string, wg *sync.WaitGroup) {
    defer wg.Done() // Goroutine 完成时调用 Done()
    fmt.Println(msg)
}

func main() {
    var wg sync.WaitGroup
    wg.Add(3) // 等待 3 个 Goroutine

    go printMessage("Hello", &wg)
    go printMessage("from", &wg)
    go printMessage("Goroutine!", &wg)

    wg.Wait() // 等待所有 Goroutine 完成
    fmt.Println("All Goroutines are done.")
}

输出：

Hello  
from  
Goroutine!  
All Goroutines are done.

解释：

• wg.Add(n) 表示需要等待 n 个 Goroutine 完成。
• 每个 Goroutine 结束时调用 wg.Done()。
• wg.Wait() 会阻塞主 Goroutine，直到所有任务完成。

七、Goroutine 的典型应用场景

1. I/O 并发：处理大量网络请求，减少响应时间。
2. 后台任务：执行定时任务、日志记录等。
3. 并行计算：分布计算任务，提高程序性能。
4. 定时器与延时操作：如每隔一段时间执行某个操作。

八、注意事项与最佳实践

1. 避免死锁：当 Goroutine 等待彼此时可能出现死锁，应小心处理共享资源。
2. 合理使用 WaitGroup 和 Channel：确保 Goroutine 的同步与通信。
3. 避免启动过多 Goroutine：虽然 Goroutine 轻量，但过多的 Goroutine 也会占用系统资源。
4. 调试工具：使用 go tool trace 和 pprof 进行性能调优和调试。

九、小结

Goroutine 是 Golang 的强大并发工具，其高效、易用的特点让它成为开发者实现并发程序的首选。在这篇博客中，我们介绍了 Goroutine 的基础用法、参数传递和同步机制，并演示了常见的应用场景和注意事项。

在下一篇博客中，我将详细介绍 通道（Channel） 的使用，它是 Goroutine 之间进行通信的主要工具。敬请期待！