Golang 并发编程入门Goroutine 简介与基础用法小结_Golang

一、什么是 goroutine？

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

1、goroutine 的特点：

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

二、如何启动 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 的关系

主 goroutine：main 函数所在的 goroutine，程序从这里开始运行。
子 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.")
}

输出：