什么是Goroutine

在Go语言中，Goroutine 是程序中最基本的并发单位。事实上，每个Go程序都会自动创建一个goroutine，那就是主goroutine，程序启动时会立即执行。Goroutine是Go语言中处理并发问题的核心工具，因此理解它的工作原理至关重要。

简而言之，Goroutine是并发执行的函数，这些函数与其他代码并行运行（注意：并不是并行，而是并发！）。你可以通过在函数前面加上 go 关键字来启动一个Goroutine：

func main() {go sayHello()// 继续执行其他操作
}func sayHello() {fmt.Println("你好")
}

这个例子中，sayHello() 函数将在一个新的goroutine中执行，而主goroutine将继续执行其他代码。你会发现Goroutine非常简单，只需一个关键字就可以创建并发执行的逻辑块。

Goroutine不仅仅适用于命名函数，匿名函数同样可以使用Goroutine：

go func() {fmt.Println("你好")
}()
// 继续执行其他操作

在这个例子中，匿名函数立即被执行，并在一个新的Goroutine中并发运行。

这种简洁的语法让Go程序员能够轻松地处理并发任务，但更重要的是要理解其背后的机制。我们将深入探讨Goroutine的工作原理，包括它们如何调度和管理。

Goroutine的幕后工作

Goroutine并不是操作系统线程，也不是传统意义上的绿色线程（语言运行时管理的线程），它们是更高层次的抽象，称为协程。协程本质上是非抢占式的并发子程序（函数、闭包等），也就是说，它们不会在任意时刻被中断，而是在特定的挂起或重新进入点进行切换。

Go语言的运行时与Goroutine紧密结合，它会自动在Goroutine阻塞时暂停它们，待其解除阻塞后再恢复执行。这使得Goroutine在某种程度上是可抢占的，但这种抢占只发生在它们被阻塞的点上。这种机制使Goroutine成为一种特殊的协程类型。

Goroutine的调度由Go的M:N调度器处理，即将M个Goroutine映射到N个操作系统线程上。当Goroutine的数量超过可用的绿色线程时，调度器会合理地分配这些Goroutine，以确保系统资源的高效利用。

Fork-Join并发模型

Go的并发模型基于一种称为fork-join的模型。在程序运行的任何时刻，它都可以通过 go 语句分支出新的并发执行路径，这就是“fork”。而这些并发执行的路径最终会在某个点重新汇合，这就是“join”。

例如：

sayHello := func() {fmt.Println("你好")
}
go sayHello()
// 继续执行其他操作

在这个例子中，sayHello 函数会在它自己的Goroutine中执行，主程序则继续运行。然而，这个例子存在一个问题：我们无法保证 sayHello 函数会执行，因为主goroutine可能会在 sayHello 被调度之前就退出。为了保证程序的正确性，我们需要一个同步点来等待所有的Goroutine完成。

同步Goroutine

可以使用 sync.WaitGroup 来同步主goroutine和其他goroutine，确保主程序在其他并发任务完成之前不会退出：

var wg sync.WaitGroupsayHello := func() {defer wg.Done()fmt.Println("你好")
}wg.Add(1)
go sayHello()
wg.Wait()

在这个例子中，wg.Wait() 会阻塞主goroutine，直到 sayHello 所在的goroutine完成。通过这种方式，我们可以确保 sayHello 的执行结果输出为“你好”。

Goroutine和闭包

Goroutine可以捕获并操作闭包中的变量。例如：

var wg sync.WaitGroup
salutation := "你好"wg.Add(1)
go func() {defer wg.Done()salutation = "欢迎"
}()
wg.Wait()
fmt.Println(salutation)

在这个例子中，salutation 变量被goroutine修改，因此输出的结果是“欢迎”。

然而，在循环中使用闭包时，情况变得稍微复杂一些：

var wg sync.WaitGroupfor _, salutation := range []string{"你好", "问候", "早安"} {wg.Add(1)go func() {defer wg.Done()fmt.Println(salutation)}()
}
wg.Wait()

很多人会认为输出顺序是不确定的“你好”、“问候”和“早安”，但实际上输出可能是三次“早安”。这是因为goroutine捕获了循环变量 salutation，而在goroutine执行时，这个变量可能已经被赋值为最后一个值了。

正确的做法是传递每次循环中的变量副本：

for _, salutation := range []string{"你好", "问候", "早安"} {wg.Add(1)go func(salutation string) {defer wg.Done()fmt.Println(salutation)}(salutation)
}
wg.Wait()

通过这样传递参数，我们确保每个goroutine都操作自己独立的变量副本，输出结果会如我们预期的那样。

Goroutine的轻量级优势

Goroutine非常轻量化，创建一个新的Goroutine仅消耗几KB的内存，而Go的运行时会动态调整栈的大小，确保内存使用的最小化。因此，在同一地址空间中可以创建成千上万个Goroutine而不会耗尽系统资源。

例如，下面的代码可以测量Goroutine的内存消耗：

memConsumed := func() uint64 {runtime.GC()var s runtime.MemStatsruntime.ReadMemStats(&s)return s.Sys
}var c <-chan interface{}
var wg sync.WaitGroup
noop := func() { wg.Done(); <-c }
const numGoroutines = 1e4wg.Add(numGoroutines)
before := memConsumed()for i := numGoroutines; i > 0; i-- {go noop()
}wg.Wait()
after := memConsumed()fmt.Printf("%.3fkb", float64(after-before)/numGoroutines/1000)

结果显示，每个Goroutine的平均内存消耗大约为2.8KB。

Goroutine的上下文切换

在操作系统层面，线程之间的上下文切换非常昂贵，因为需要保存寄存器值、内存映射等。而在Go的调度器中，Goroutine的上下文切换成本相对较低，调度器只需要保存必要的状态。

下图展示了Goroutine与操作系统线程之间的上下文切换速度比较：

go test -bench=. -cpu=1
BenchmarkContextSwitch 5000000 225 ns/op PASS

在这个基准测试中，Goroutine的上下文切换速度比操作系统线程快了92%。

总结

通过本文的讨论，你应该了解了如何启动Goroutine及其工作原理。Goroutine作为Go语言中处理并发的核心工具，其轻量级和高效的特性使得我们可以轻松地创建成千上万个并发任务。同时，利用 sync.WaitGroup 等工具进行Goroutine的同步，可以确保程序的正确性和稳定性。

Goroutine是Go语言中非常强大的并发构件，既适合简单的并发任务，也能应对复杂的大规模并发场景。在实际开发中，只要需求合适，不妨大胆使用Goroutine！