Go语言的Goroutine是支撑其高并发能力的核心特性，每个Goroutine都有独立的生命周期，而主函数作为程序的入口，其退出行为会直接影响所有未结束的Goroutine的运行状态，因此掌握Goroutine生命周期管理以及主函数退出与并发协程的同步方法，是Go并发编程的基础能力。
Goroutine生命周期的基本流程
Goroutine的生命周期通常分为四个阶段：创建、运行、阻塞、退出。当我们在代码中通过go关键字调用函数时，就会创建一个新的Goroutine，此时它会进入可运行状态，等待Go运行时调度到系统线程上执行。执行过程中如果遇到通道读写、锁等待、系统调用等操作，Goroutine会进入阻塞状态，让出执行资源。当函数执行完成、遇到panic或者主函数退出时，Goroutine就会进入退出状态，释放相关资源。
主函数退出对Goroutine的影响
Go程序的主函数运行在一个特殊的Goroutine中，当主函数执行完毕退出时，整个程序会直接终止，不会等待其他普通的Goroutine执行完成。我们可以通过一个简单的示例来验证这个特性：
package main
import (
"fmt"
"time"
)
func subGoroutine() {
time.Sleep(2 * time.Second)
fmt.Println("子协程执行完成")
}
func main() {
go subGoroutine()
fmt.Println("主函数执行完成")
}
运行上述代码会发现，程序只会输出“主函数执行完成”，子协程的睡眠和输出逻辑都不会执行，因为主函数退出后整个程序直接终止了。如果我们需要主函数等待子协程完成后再退出，就需要用到并发协程同步的相关机制。
常用的并发协程同步方案
1. 使用通道（Channel）同步
通道是Go语言内置的协程间通信工具，我们可以通过无缓冲通道实现主协程和子协程的同步。子协程执行完成后向通道发送信号，主协程阻塞等待接收信号，这样就能保证主函数不会提前退出。
package main
import (
"fmt"
"time"
)
func subGoroutine(finishChan chan struct{}) {
time.Sleep(2 * time.Second)
fmt.Println("子协程执行完成")
// 向通道发送完成信号
finishChan <- struct{}{}
}
func main() {
finishChan := make(chan struct{})
go subGoroutine(finishChan)
// 阻塞等待子协程完成信号
<-finishChan
fmt.Println("主函数执行完成")
}
这种方式的优点是简单直观，适合单个或者少量协程的同步场景，如果有多个协程需要同步，就需要创建多个通道或者复用通道，逻辑会相对复杂。
2. 使用sync.WaitGroup同步
当需要等待多个Goroutine都执行完成时，sync.WaitGroup是更合适的选择。它内部维护了一个计数器，我们可以通过Add方法增加计数，每个协程执行完成后调用Done方法减少计数，主协程通过Wait方法阻塞等待计数器归零。
package main
import (
"fmt"
"sync"
"time"
)
func subGoroutine(id int, wg *sync.WaitGroup) {
defer wg.Done()
time.Sleep(time.Duration(id) * time.Second)
fmt.Printf("子协程%d执行完成n", id)
}
func main() {
var wg sync.WaitGroup
// 启动3个子协程
for i := 1; i <= 3; i++ {
wg.Add(1)
go subGoroutine(i, &wg)
}
// 等待所有子协程完成
wg.Wait()
fmt.Println("主函数执行完成")
}
使用WaitGroup时需要注意，Add方法的调用要在启动协程之前完成，避免协程启动后还没来得及调用Add主协程就已经执行Wait导致逻辑错误，同时Done方法最好放在defer中，避免协程中途退出导致计数器没有减少。
3. 使用Context控制协程生命周期
如果我们需要主动控制Goroutine的退出，比如设置超时、取消任务，context.Context是官方推荐的工具。我们可以通过context.WithCancel或者context.WithTimeout创建上下文，子协程监听上下文的Done通道，当上下文被取消或者超时时，子协程主动退出。
package main
import (
"context"
"fmt"
"time"
)
func subGoroutine(ctx context.Context, id int) {
for {
select {
case <-ctx.Done():
fmt.Printf("子协程%d收到退出信号，停止执行n", id)
return
default:
fmt.Printf("子协程%d正在执行任务n", id)
time.Sleep(1 * time.Second)
}
}
}
func main() {
// 创建可取消的上下文
ctx, cancel := context.WithCancel(context.Background())
// 启动2个子协程
for i := 1; i <= 2; i++ {
go subGoroutine(ctx, i)
}
time.Sleep(3 * time.Second)
// 调用取消函数，通知所有子协程退出
cancel()
// 等待子协程处理退出逻辑
time.Sleep(1 * time.Second)
fmt.Println("主函数执行完成")
}
Context可以跨协程传递，适合复杂的并发场景中控制多个关联协程的生命周期，比如一个请求触发多个下游协程处理，当请求取消时所有相关协程都停止工作。
Goroutine生命周期管理的注意事项
- 避免创建无限制的Goroutine，过多的Goroutine会占用大量内存，甚至导致程序崩溃，必要时可以使用协程池控制并发数量。
- 确保Goroutine有明确的退出路径，避免出现永远阻塞的Goroutine，造成资源泄漏。
- 不要在Goroutine中直接使用主协程的局部变量，避免数据竞争，尽量通过通道或者同步原语传递数据。
- 如果Goroutine中可能出现
panic，最好添加recover逻辑，避免单个协程的崩溃导致整个程序退出。
总结
Goroutine的生命周期管理和主函数退出、并发协程同步是紧密相关的，主函数退出会直接终止所有未结束的Goroutine，因此我们需要根据场景选择合适的同步方式。单个协程同步可以使用通道，多个协程等待完成可以使用WaitGroup，需要主动控制协程退出可以使用Context。合理的生命周期管理能避免很多并发编程中的常见问题，提升程序的稳定性和可靠性。