Go语言Goroutine并发控制：确保子协程完成的同步机制-Golang-PHP中文网

Go语言Goroutine并发控制：确保子协程完成的同步机制

花韻仙語

发布： 2025-10-20 11:12:01

原创

172人浏览过

Go语言Goroutine并发控制：确保子协程完成的同步机制

go语言中，主函数退出会导致所有子goroutine终止。本文将深入探讨这一行为，并提供使用`sync.waitgroup`和channel两种核心同步机制，以确保并发任务在程序退出前优雅完成的实践方法。

理解Goroutine的生命周期与主程序退出

在Go语言中，当main函数执行完毕并退出时，整个程序会立即终止。这意味着，即使我们使用go关键字启动了其他的goroutine，如果main函数没有等待它们完成就退出了，这些goroutine也可能没有机会执行完毕，甚至根本不会开始执行。这与传统操作系统线程的行为有所不同，传统线程通常在所有用户线程结束后才退出进程。

考虑以下示例代码：

package main

import "fmt"

func f(from string) {
    for i := 0; i < 3; i++ {
        fmt.Println(from, ":", i)
    }
}

func main() {
    go f("direct")
    go f("redirect")
    // main函数在此处直接退出
}

登录后复制

当运行这段代码时，你可能会发现没有任何输出，或者只输出了一部分内容。这是因为main函数启动了两个goroutine后，并没有等待它们执行，而是立即退出了。为了解决这个问题，我们需要引入同步机制，确保main函数在所有并发任务完成后才退出。

使用sync.WaitGroup进行同步

sync.WaitGroup是Go标准库提供的一种简单且常用的同步原语，用于等待一组goroutine完成。它的工作原理是维护一个内部计数器：

立即学习“go语言免费学习笔记（深入）”；

Add(delta int)：将计数器增加delta。通常在启动goroutine之前调用，表示要等待的goroutine数量。
Done()：减少计数器。每个goroutine完成其任务后调用此方法。
Wait()：阻塞当前goroutine（通常是main），直到计数器归零。

下面是使用sync.WaitGroup修改后的示例：

云雀语言模型

云雀是一款由字节跳动研发的语言模型，通过便捷的自然语言交互，能够高效的完成互动对话

查看详情

package main

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

func f(from string, wg *sync.WaitGroup) {
    defer wg.Done() // 确保goroutine结束时调用Done()
    for i := 0; i < 3; i++ {
        fmt.Println(from, ":", i)
    }
}

func main() {
    var wg sync.WaitGroup // 声明一个WaitGroup
    wg.Add(2)             // 设置计数器为2，表示要等待两个goroutine

    go f("direct", &wg)   // 启动第一个goroutine，并传入WaitGroup的指针
    go f("redirect", &wg) // 启动第二个goroutine，并传入WaitGroup的指针

    wg.Wait() // 阻塞main函数，直到所有goroutine都调用了Done()
    fmt.Println("所有goroutine已完成。")
}

登录后复制

在这个例子中，main函数首先初始化一个WaitGroup，并使用Add(2)将其计数器设置为2。然后，它启动两个f函数作为goroutine，并将wg的地址传递给它们。每个f函数在执行完毕前，会通过defer wg.Done()确保计数器减一。最后，main函数调用wg.Wait()，这会使main函数阻塞，直到wg的计数器变为0，即所有子goroutine都已完成。

使用Channel进行同步

Channel是Go语言中用于goroutine之间通信和同步的强大工具。我们也可以利用channel的阻塞特性来实现goroutine的同步。通过让每个goroutine完成任务后向channel发送一个信号，而main函数则等待接收这些信号，可以确保所有goroutine都已执行完毕。

package main

import (
    "fmt"
)

func f(from string, ch chan<- bool) { // ch chan<- bool 表示只发送的channel
    for i := 0; i < 3; i++ {
        fmt.Println(from, ":", i)
    }
    ch <- true // goroutine完成时发送一个信号到channel
}

func main() {
    ch := make(chan bool) // 创建一个无缓冲的bool类型channel

    go f("direct", ch)   // 启动第一个goroutine，并传入channel
    go f("redirect", ch) // 启动第二个goroutine，并传入channel

    <-ch // 阻塞，直到从ch接收到第一个信号
    <-ch // 阻塞，直到从ch接收到第二个信号
    fmt.Println("所有goroutine已完成。")
}

登录后复制

在这个例子中，main函数创建了一个无缓冲的bool类型channel。每个f函数在完成任务后，会向这个channel发送一个true值。由于channel是无缓冲的，发送操作会阻塞，直到有接收方准备好接收。在main函数中，我们通过两次<-ch操作来等待接收两个信号。只有当两个信号都接收到后，main函数才会继续执行并最终退出。

总结与注意事项

sync.WaitGroup vs. Channel:
- sync.WaitGroup适用于“等待一组任务完成”的场景，它更简洁直接，不需要传递具体的数据，只关注完成状态。
- Channel则更通用，除了同步，还可以用于goroutine之间的数据传递和更复杂的协调逻辑。当需要从goroutine返回结果或进行更复杂的通信时，channel是更好的选择。
避免select{}: 在某些情况下，为了防止main函数退出，有人可能会在main函数末尾添加select{}。这会使main函数无限期阻塞，从而允许其他goroutine运行。然而，这会导致程序永远不会正常退出，形成死锁，不适用于生产环境。
错误处理与上下文取消: 在实际的并发编程中，还需要考虑错误处理和goroutine的优雅取消。context包提供了强大的机制来管理goroutine的生命周期，包括超时、取消信号等。
资源清理: 确保所有goroutine在完成任务后释放了它们可能持有的资源，例如文件句柄、网络连接等。