Goroutines 的工作原理及主进程结束后 Goroutines 的生命周期-Golang-PHP中文网

Goroutines 的工作原理及主进程结束后 Goroutines 的生命周期

碧海醫心

发布： 2025-10-08 11:18:38

原创

608人浏览过

goroutines 的工作原理及主进程结束后 goroutines 的生命周期

Goroutines 是 Go 语言并发编程的核心。理解 Goroutines 的工作方式以及它们在主进程结束后的行为至关重要。本文将深入探讨 Goroutines 的生命周期，以及如何使用 sync.WaitGroup 来确保 Goroutines 完成任务。

Goroutines 的基本概念

Goroutines 本质上是轻量级的线程，由 Go 运行时（runtime）管理。与传统的线程相比，Goroutines 的创建和销毁开销更小，切换速度更快，因此可以在程序中创建大量的 Goroutines 来实现并发执行。

当程序启动时，会创建一个主 Goroutine 来执行 main 函数。可以通过 go 关键字来启动新的 Goroutines，每个 Goroutine 都会并发地执行指定的函数。

package main

import (
    "fmt"
    "time"
)

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

func main() {
    for i := 1; i <= 3; i++ {
        go worker(i)
    }

    // 暂停几秒钟，让 worker 线程有机会运行
    time.Sleep(time.Second * 2)
}

登录后复制

在这个例子中，main 函数启动了三个 Goroutines，每个 Goroutine 执行 worker 函数。worker 函数会打印一条消息，暂停一秒钟，然后再次打印一条消息。main 函数暂停了两秒钟，以便让 Goroutines 有机会完成执行。

Goroutines 的生命周期

Goroutines 的生命周期始于 go 关键字的调用，终于函数的执行完成。需要注意的是，当 main 函数返回时，程序会立即退出，不会等待其他 Goroutines 完成执行。这意味着，如果 main 函数在 Goroutines 完成之前退出，那么这些 Goroutines 就会被强制终止，可能导致数据丢失或程序状态不一致。

使用 sync.WaitGroup 管理 Goroutines

为了确保 Goroutines 完成任务后再退出程序，可以使用 sync.WaitGroup。sync.WaitGroup 提供了一种简单的机制来等待一组 Goroutines 完成执行。

sync.WaitGroup 的使用步骤如下：

天工

昆仑万维推出的通用AI智能体平台，原天工AI

212

查看详情

创建 sync.WaitGroup 实例：在 main 函数中创建一个 sync.WaitGroup 实例。
增加计数器：在启动每个 Goroutine 之前，调用 wg.Add(1) 来增加计数器。
标记完成：在每个 Goroutine 的结束处，调用 wg.Done() 来标记完成，减少计数器。
等待完成：在 main 函数中，调用 wg.Wait() 来等待计数器归零，即所有 Goroutines 都已完成。

package main

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

func worker(id int, wg *sync.WaitGroup) {
    defer wg.Done() // 确保在函数退出时调用 Done()

    fmt.Printf("Worker %d starting\n", id)
    time.Sleep(time.Second)
    fmt.Printf("Worker %d done\n", id)
}

func main() {
    var wg sync.WaitGroup

    for i := 1; i <= 3; i++ {
        wg.Add(1) // 启动一个 worker 线程，增加计数器
        go worker(i, &wg)
    }

    wg.Wait() // 阻塞直到计数器归零
    fmt.Println("All workers done")
}

登录后复制

在这个例子中，main 函数在启动每个 worker Goroutine 之前调用 wg.Add(1)，在 worker 函数的结束处调用 wg.Done()。main 函数调用 wg.Wait() 来等待所有 worker Goroutines 完成执行。

示例：并发插入 MongoDB

以下代码演示了如何使用 Goroutines 和 sync.WaitGroup 并发地向 MongoDB 插入数据。

package main

import (
    "fmt"
    "labix.org/v2/mgo"
    "strconv"
    "sync"
    "time"
)

// Reading 结构体
type Reading struct {
    Id   string
    Name string
}

func main() {
    // 设置计时器
    startTime := time.Now()

    // 设置集合
    collection := getCollection("test", "readings")
    fmt.Println("collection complete: " + strconv.FormatFloat(time.Since(startTime).Seconds(), 'f', 2, 64))

    // 准备 readings
    readings := prepareReadings()
    fmt.Println("readings prepared: " + strconv.FormatFloat(time.Since(startTime).Seconds(), 'f', 2, 64))

    var waitGroup sync.WaitGroup

    // 插入 readings
    for i := 1; i <= 1000000; i++ {
        waitGroup.Add(1)
        go insertReadings(collection, readings, &waitGroup)

        if i%100000 == 0 {
            fmt.Println("100000 readings queued for insert: " + strconv.FormatFloat(time.Since(startTime).Seconds(), 'f', 2, 64))
        }
    }
    waitGroup.Wait()

    fmt.Println("all readings inserted: " + strconv.FormatFloat(time.Since(startTime).Seconds(), 'f', 2, 64))
}

func getCollection(databaseName string, tableName string) *mgo.Collection {
    session, err := mgo.Dial("localhost")

    if err != nil {
        fmt.Println("error getCollection:", err)
        panic(err)
    }

    collection := session.DB(databaseName).C(tableName)

    return collection
}

func insertReadings(collection *mgo.Collection, readings []Reading, waitGroup *sync.WaitGroup) {
    defer waitGroup.Done()

    err := collection.Insert(readings)

    if err != nil {
        fmt.Println("error insertReadings:", err)
    }
}

func prepareReadings() []Reading {
    var readings []Reading
    for i := 1; i <= 1; i++ {
        readings = append(readings, Reading{Name: "Thing"})
    }

    return readings
}

登录后复制

在这个例子中，insertReadings 函数接收一个 sync.WaitGroup 指针，并在函数结束时调用 waitGroup.Done()。main 函数在启动每个 insertReadings Goroutine 之前调用 waitGroup.Add(1)，并使用 waitGroup.Wait() 等待所有 Goroutines 完成。

注意事项：