本文深入探讨go语言中goroutine的defer语句在主程序提前结束时可能不被调用的现象。通过分析其并发执行机制，我们揭示了主goroutine不等待其他子goroutine完成的特性。教程将重点介绍如何利用sync.waitgroup等同步原语，确保子goroutine在主程序退出前完成执行，从而保证其内部的defer逻辑得以正确执行，有效管理并发流程。
在Go语言中，defer语句用于确保一个函数调用（或方法调用）在包含它的函数执行完毕前被执行，无论该函数是正常返回还是发生了panic。这在资源清理、解锁互斥锁等场景中非常有用。然而，当defer语句存在于一个新创建的goroutine中时，其行为可能会出乎意料，尤其是在主goroutine（即main函数）提前结束的情况下。
理解Goroutine与Defer的并发行为
考虑以下Go程序示例：
package main
import (
"fmt"
"time"
)
func main() {
fmt.Println("1")
defer fmt.Println("-1") // 主goroutine的defer
go func() {
fmt.Println("2")
defer fmt.Println("-2") // 子goroutine的defer
time.Sleep(9 * time.Second) // 模拟长时间工作
}()
time.Sleep(1 * time.Second) // 主goroutine短暂等待
fmt.Println("3")
}运行上述代码，通常会得到如下输出：
1 2 3 -1
观察发现，go func() { ... } 内部的 defer fmt.Println("-2") 并没有被执行。这与我们对defer的常规理解似乎不符。
立即学习“go语言免费学习笔记（深入）”；
原因分析：
问题的核心在于Go程序的生命周期。main函数所在的goroutine是程序的入口和主控流程。当main函数执行完毕时，Go运行时会终止整个程序，而不会等待其他非main goroutine的完成。在上面的例子中，主goroutine在执行完fmt.Println("3")和其自身的defer fmt.Println("-1")之后，便结束了。此时，子goroutine虽然被创建并开始执行，但由于它内部的time.Sleep(9 * time.Second)尚未完成，甚至可能还未开始执行，主程序就已经退出了。因此，子goroutine的生命周期被突然中断，其内部的defer语句自然也就没有机会被调用。
这种行为并非defer放置位置的问题，而是并发编程中常见的竞态条件（Race Condition）——即程序的正确性依赖于不受控制的事件时序。为了确保子goroutine有机会完成其工作，包括执行其内部的defer语句，主goroutine必须显式地等待子goroutine的完成。
解决方案：显式同步机制
Go语言提供了多种并发原语来管理goroutine之间的同步，其中最常用且适合此场景的是sync.WaitGroup和通道（Channel）。
1. 使用 sync.WaitGroup
sync.WaitGroup 是一个计数器，用于等待一组goroutine完成。它有三个主要方法：
- Add(delta int)：将计数器增加delta。通常在创建goroutine之前调用，表示将要启动多少个goroutine。
- Done()：将计数器减1。通常在goroutine完成其工作时调用。
- Wait()：阻塞当前goroutine，直到计数器归零。
下面是使用sync.WaitGroup改进后的代码示例：
package main
import (
"fmt"
"sync" // 导入sync包
"time"
)
func main() {
var wg sync.WaitGroup // 声明一个WaitGroup
fmt.Println("1")
defer fmt.Println("-1") // 主goroutine的defer
wg.Add(1) // 增加计数器，表示有一个goroutine需要等待
go func() {
defer wg.Done() // goroutine完成时调用Done()
fmt.Println("2")
defer fmt.Println("-2") // 子goroutine的defer
time.Sleep(2 * time.Second) // 模拟工作时间，缩短以观察效果
fmt.Println("Goroutine finished its work.")
}()
time.Sleep(1 * time.Second) // 主goroutine短暂等待
fmt.Println("3")
wg.Wait() // 阻塞主goroutine，直到所有Add的goroutine都调用了Done()
fmt.Println("Main goroutine exiting.")
}运行上述代码，输出将变为：
1 2 3 Goroutine finished its work. -2 Main goroutine exiting. -1
现在，go func() { ... } 内部的 defer fmt.Println("-2") 成功执行了。这是因为wg.Wait()确保了主goroutine会一直等待，直到子goroutine执行了defer wg.Done()，表示其工作（包括其内部的defer语句）已经完成。
注意事项：
- wg.Add()应该在启动goroutine之前调用，以避免竞态条件（即goroutine在Add之前完成并调用Done，导致Wait无法正确工作）。
- defer wg.Done()是确保Done()总是在goroutine退出前被调用的最佳实践，即使发生了panic。
2. 使用通道（Channel）进行同步
通道也可以用于同步goroutine。例如，子goroutine可以在完成工作后向一个通道发送一个信号，而主goroutine则阻塞等待从该通道接收信号。
package main
import (
"fmt"
"time"
)
func main() {
done := make(chan struct{}) // 创建一个用于同步的通道
fmt.Println("1")
defer fmt.Println("-1")
go func() {
fmt.Println("2")
defer fmt.Println("-2")
time.Sleep(2 * time.Second)
fmt.Println("Goroutine finished its work.")
close(done) // 关闭通道，通知主goroutine完成
}()
time.Sleep(1 * time.Second)
fmt.Println("3")
<-done // 阻塞主goroutine，直到从通道接收到信号（通道被关闭）
fmt.Println("Main goroutine exiting.")
}此代码也会产生与WaitGroup版本相同的正确输出。通道在需要传递数据或进行更复杂的协调时更为强大。
总结
在Go语言中处理并发时，理解main goroutine的生命周期以及它与其他子goroutine的关系至关重要。defer语句的行为是与它所在的函数/goroutine的生命周期绑定的。如果一个goroutine在完成其所有任务（包括执行defer栈中的函数）之前就被主程序终止，那么其内部的defer语句将不会被调用。
为了确保所有goroutine都能正常完成并执行其清理逻辑，我们必须使用显式的同步机制，如sync.WaitGroup或通道。sync.WaitGroup适用于“等待一组任务完成”的场景，而通道则在需要进行数据交换或更精细的控制流时表现出其灵活性。正确地管理goroutine的生命周期和同步，是编写健壮、高效Go并发程序的关键。
