Go语言并发编程：理解goroutine的执行与主协程同步

Golang不知道大家是否熟悉？今天我将给大家介绍《Go语言并发编程：理解goroutine的执行与主协程同步 》，这篇文章主要会讲到等等知识点，如果你在看完本篇文章后，有更好的建议或者发现哪里有问题，希望大家都能积极评论指出，谢谢！希望我们能一起加油进步！

本文深入探讨了Go语言中goroutine并发执行时，因主协程过早退出导致子协程无法完成任务的问题。通过分析问题根源，我们排除了不推荐的`time.Sleep`方案，并详细介绍了如何使用`sync.WaitGroup`这一标准库提供的同步原语，来确保主协程等待所有子协程执行完毕，从而实现可靠的并发程序控制。

在Go语言中，goroutine是实现并发编程的核心机制。它是一种轻量级的线程，允许函数在独立的执行流中运行。然而，初学者在使用goroutine时常会遇到一个常见问题：启动了goroutine，但程序却没有预期的输出。这通常不是因为goroutine没有被执行，而是主协程（main函数所在的协程）在子协程完成其工作之前就退出了。

问题现象与原因分析

考虑以下Go程序代码：

package main

import "fmt"

func f(msg string) {
    fmt.Println(msg)
    return
}

func main() {
    go f("goroutine")

    go func(msg string) {
        fmt.Println(msg)
        return
    }("going")

    return
}

当运行这段代码时，你可能会发现控制台没有任何输出。如果移除go关键字，程序会正常打印"goroutine"和"going"。这是因为当go关键字被使用时，f("goroutine")和匿名函数都被作为独立的goroutine启动，它们与main函数所在的协程并发执行。

Go程序的执行流程是，当main函数执行完毕时，整个程序就会退出。如果main函数在启动了其他goroutine之后立即返回，那么这些子goroutine可能还没有来得及被调度执行，或者只执行了一部分，程序就已经终止了。这就像一个乐队指挥在乐手们还没开始演奏之前就离开了舞台，导致音乐无法奏响。

不推荐的解决方案：time.Sleep()

为了解决这个问题，一种直观但不推荐的做法是在main函数末尾添加一个短暂的暂停，例如使用time.Sleep()：

package main

import (
    "fmt"
    "time" // 引入 time 包
)

func f(msg string) {
    fmt.Println(msg)
    return
}

func main() {
    go f("goroutine")

    go func(msg string) {
        fmt.Println(msg)
        return
    }("going")

    time.Sleep(2 * time.Second) // 暂停 2 秒
    return
}

这种方法在某些情况下似乎有效，因为main协程暂停了一段时间，给了其他goroutine执行的机会。然而，它存在严重的缺陷：

1. 不可靠性： 无法保证2秒的暂停时间足够所有goroutine完成。如果goroutine的执行时间超过2秒，程序仍然会提前退出。
2. 效率低下： 如果goroutine在很短的时间内就完成了，main协程却要无谓地等待2秒，浪费了宝贵的执行时间。
3. 非确定性： 程序的行为依赖于调度器的具体实现和系统负载，可能在不同环境下表现不一致。

因此，time.Sleep()不应作为goroutine同步的通用解决方案。

推荐的解决方案：使用sync.WaitGroup进行同步

Go标准库提供了sync.WaitGroup类型，它是专门用于等待一组goroutine完成的同步原语。WaitGroup的工作原理是维护一个内部计数器，当计数器归零时，Wait()方法就会解除阻塞。

sync.WaitGroup主要有三个方法：

• Add(delta int)：将计数器增加delta。通常在启动goroutine之前调用，表示有多少个goroutine需要等待。
• Done()：将计数器减1。通常在goroutine完成其工作时调用。
• Wait()：阻塞当前goroutine，直到计数器变为0。

下面是使用sync.WaitGroup改进后的代码示例：

package main

import (
    "fmt"
    "sync" // 引入 sync 包
)

func f(msg string, wg *sync.WaitGroup) {
    defer wg.Done() // 确保在函数退出时调用 Done()
    fmt.Println(msg)
}

func main() {
    var wg sync.WaitGroup // 声明一个 WaitGroup 变量

    // 启动第一个 goroutine
    wg.Add(1) // 计数器加1，表示有一个 goroutine 需要等待
    go f("goroutine", &wg) // 将 WaitGroup 的地址传递给 goroutine

    // 启动第二个 goroutine
    wg.Add(1) // 计数器加1
    go func(msg string) {
        defer wg.Done() // 确保在函数退出时调用 Done()
        fmt.Println(msg)
    }("going")

    wg.Wait() // 阻塞 main 协程，直到计数器归零
    fmt.Println("所有 goroutine 已完成。")
}

在这个改进后的程序中：

1. main函数首先声明了一个sync.WaitGroup变量wg。
2. 在启动每个goroutine之前，wg.Add(1)被调用，将WaitGroup的计数器增加1。这告诉WaitGroup，有一个新的goroutine需要被等待。
3. f函数和匿名函数现在都接收一个*sync.WaitGroup类型的参数。在这些goroutine的内部，defer wg.Done()被调用。defer关键字确保了无论goroutine如何退出（正常完成或发生panic），wg.Done()都会被执行，从而将WaitGroup的计数器减1。
4. 最后，main函数调用wg.Wait()。这会阻塞main协程，直到WaitGroup的计数器变为0（即所有通过Add增加的goroutine都调用了Done）。一旦计数器归零，main协程就会解除阻塞，并继续执行，此时所有子goroutine都已经完成了它们的任务。

运行此程序，你将看到预期的输出，并且程序会等待所有goroutine执行完毕后才退出。

注意事项与最佳实践

• WaitGroup的传递： 总是将WaitGroup作为指针（*sync.WaitGroup）传递给goroutine。如果按值传递，每个goroutine将拥有WaitGroup的一个副本，它们之间的操作将无法同步。
• Add()的调用时机： 务必在启动goroutine之前调用wg.Add()。如果在goroutine启动之后但在wg.Wait()之前调用Add()，可能会导致Wait()在计数器尚未完全更新之前就被解除阻塞，从而产生竞态条件。
• Done()的放置： 最佳实践是在goroutine函数的开头使用defer wg.Done()。这可以确保即使函数提前返回或发生错误，Done()也能被正确调用。
• 避免负计数： 不要调用比Add()更多的Done()，这会导致程序panic。
• Wait()的唯一性： Wait()方法通常只在主协程中调用一次。

总结

goroutine是Go语言实现并发的强大工具，但正确地管理它们的生命周期和与主程序的同步至关重要。当goroutine中的代码没有打印输出时，最常见的原因是主协程没有等待子协程完成就退出了。sync.WaitGroup提供了一种简洁、高效且健壮的机制来解决这个问题，它允许主协程等待一组并发任务的完成，是Go语言并发编程中不可或缺的同步原语。通过熟练掌握sync.WaitGroup，开发者可以编写出更加可靠和高效的并发Go程序。

本篇关于《Go语言并发编程：理解goroutine的执行与主协程同步 》的介绍就到此结束啦，但是学无止境，想要了解学习更多关于Golang的相关知识，请关注golang学习网公众号！