平时我们编写的普通程序,默认都是从上往下 “顺序执行” 的。只有当前面的函数执行完毕后,后面的代码才能开始运行。如果前一个操作比较耗时,后面的代码就只能停在原地干等。
在实际开发中,我们经常希望程序能够同时处理多件事情,比如一边下载文件、一边响应用户的界面操作,这就需要用到 “并发编程”。在 Go 语言中,开启并发任务非常简单,我们只需要在函数调用前加上 go 关键字,就可以启动一个 “协程(Goroutine)”。
很多初学的小伙伴刚接触并发时会好奇:多个协程到底是轮流执行,还是真的同时在跑?其实这取决于电脑的 CPU 核心数:在单核 CPU 上,多个协程会快速交替推进;而在我们日常使用的多核 CPU 上,Go 运行时会自动把不同协程分配到多个核心上真正同时运行。
使用 go 关键字启动协程
“Goroutine” 是由 “Go” 和 “coroutine(协程)” 组合而成的词,专指 Go 语言中的协程。如果我们想让某个函数在后台并发执行,只需要在调用语句的最前面加上 go 关键字就可以了。
语法:
go 函数名(参数列表)说明:
当程序执行到 go 函数名(参数列表) 这条语句时,Go 会在后台创建一个新的子协程去执行该函数。此时,当前所在的 main() 函数不会停下来等待子协程运行完毕,而是直接继续往下执行后面的代码。
示例 1:启动单个子协程
package main
import (
"fmt"
"time"
)
func task() {
fmt.Println("子协程正在运行")
}
func main() {
go task() // 启动子协程
fmt.Println("main 主函数正在运行")
time.Sleep(100 * time.Millisecond) // 暂停等待子协程
}运行结果如下。
main 主函数正在运行
子协程正在运行分析:
go task() 表示启动一个新的子协程去执行 task() 函数。由于创建新协程需要极短暂的准备时间,而 main() 函数发起调用后不会原地等待,它会直接往下执行 fmt.Println("main 主函数正在运行")。
因此从运行结果可以看到,控制台会先输出 "main 主函数正在运行",紧接着再输出子协程里的 "子协程正在运行"。代码末尾的 time.Sleep() 用来让 main() 函数稍微停顿 100 毫秒,给子协程留出运行和打印的时间。
注意: go 关键字后面必须跟一个完整的函数调用。此外,如果该函数带有返回值,我们不能像普通调用那样用变量直接接收结果,比如写成 res := go add(10, 20) 就会直接报错。这是因为 go 语句发起后程序会立刻往下走,此时子协程还没有算出返回值。
同时启动多个协程
平时我们按普通方式连续调用两个函数时,程序必须等第 1 个函数全部执行完,才能开始执行第 2 个函数。如果在函数调用前都加上 go 关键字,就可以同时启动多个子协程并发执行,两者的执行流程对比如下图所示。

下面我们通过一个例子来看看多个协程同时运行的效果。
示例 2:同时启动多个子协程
package main
import (
"fmt"
"time"
)
func download(name string) {
for i := 1; i <= 2; i++ {
fmt.Printf("%s:正在下载第 %d 部分\n", name, i)
time.Sleep(50 * time.Millisecond)
}
}
func main() {
go download("文件 A") // 启动子协程 1
go download("文件 B") // 启动子协程 2
time.Sleep(200 * time.Millisecond)
}运行结果如下。
文件 B:正在下载第 1 部分
文件 A:正在下载第 1 部分
文件 A:正在下载第 2 部分
文件 B:正在下载第 2 部分分析:
在这个例子中,download() 函数每次调用都会循环打印 2 步,每步间隔 50 毫秒。如果是普通的顺序调用,程序必须等文件 A 的两部分全部下载完,才会轮到文件 B 开始。
加上 go 启动两个子协程后,文件 A 和文件 B 会同时开始下载,因此两者的输出会交替出现,总耗时也缩短了将近一半。
可能有些小伙伴会觉得奇怪:“为什么有时候是文件 B 先输出,有时候又是文件 A 先输出呢?” 这是因为多个协程是由 Go 运行时在后台并发调度的,谁先抢到执行机会具有随机性,所以每次运行的输出顺序都可能略有不同。
结合匿名函数启动协程
除了调用提前定义好的普通函数,我们还可以结合匿名函数来启动协程。当需要在后台执行的逻辑只有简短几行代码时,这种写法在实际开发中最为常用。
语法:
go func(参数列表) {
// 函数体
}(实参列表)说明:
这组语法拆成前后两部分就很好理解了:前半部分的 func(参数列表) { ... } 用于定义匿名函数,紧跟在右花括号 } 后面的 (实参列表) 表示定义完立即调用它。如果不需要传入参数,两边留空写成 go func() { ... }() 即可。
示例 3:无参匿名函数启动协程
package main
import (
"fmt"
"time"
)
func main() {
go func() {
fmt.Println("匿名子协程正在运行")
}()
time.Sleep(100 * time.Millisecond)
}运行结果如下。
匿名子协程正在运行分析:
go func() { ... }() 直接在 main() 函数内部定义并启动了一个匿名子协程,省去了在外部单独定义函数的步骤。
我们在写这段代码时,千万不要漏掉右花括号 } 后面的那对空括号 ()。如果漏写了 (),就只是定义了一个匿名函数而没有调用它,编译器会直接报 expression in go must be function call 错误,提示 go 语句后面必须是函数调用。
// 正确方式
go func() {
fmt.Println("匿名子协程正在运行")
}()
// 错误方式
go func() {
fmt.Println("匿名子协程正在运行")
}如果我们希望在启动匿名子协程时把外部的数据传进去,又应该怎么写呢?请看下面这个例子。
示例 4:带参匿名函数启动协程
package main
import (
"fmt"
"time"
)
func main() {
msg := "Hello, lvye"
go func(text string) {
time.Sleep(20 * time.Millisecond)
fmt.Printf("子协程收到消息:%s\n", text)
}(msg)
msg = "已修改的新消息" // 主协程紧接着修改了外部变量
time.Sleep(100 * time.Millisecond)
}运行结果如下。
子协程收到消息:Hello, lvye分析:
在这个例子中,我们在 func(text string) 中定义了形参 text,并在末尾的 (msg) 中把外部变量 msg 传了进去。虽然主协程紧接着就把 msg 改成了 "已修改的新消息",但子协程依然稳定打印出了 "Hello, lvye"。
为什么不直接在匿名函数里读取外部的 msg,而要通过参数传进去呢?如果直接读取外部变量,等到子协程真正开始执行时,外部的 msg 已经被主协程改掉了,打印出来的就会是 "已修改的新消息"。通过参数传值,可以在启动协程的那一刻把当前值复制一份固定下来,避免受到外部修改的干扰。
顺便提一点,早期版本在 for 循环中启动匿名协程时,不传参很容易出现多个协程共享同一个循环变量的坑。虽然 Go 1.22 已经修复了这个问题,但显式传参依然能让数据来源更清晰、兼容旧版本。平时小伙伴们可以养成这个好习惯。
主协程退出会发生什么?
在 Go 程序中,main() 函数本身也是运行在一个协程里的,我们通常把它称为 “主协程”。对于主协程和子协程的关系,小伙伴们需要记住一条重要规则:一旦 main() 主协程执行结束,整个程序就会立即退出,此时所有还在后台运行的子协程也会随之终止。
对于前面的示例 1 来说,如果我们把 main() 函数末尾的 time.Sleep() 去掉,会发生什么现象呢?下面我们实际运行验证一下。
示例 5:主协程不等待直接退出
package main
import "fmt"
func task() {
fmt.Println("子协程正在运行")
}
func main() {
go task() // 启动子协程
fmt.Println("main 主函数正在运行")
}运行结果如下。
main 主函数正在运行分析:
从运行结果可以看出,去掉 time.Sleep() 之后,控制台只输出了 "main 主函数正在运行",而子协程里的 "子协程正在运行" 并没有打印出来。
这是因为启动新协程需要一点点调度准备时间。当 go task() 刚刚派发出去、还没来得及真正执行时,main() 主协程已经执行完下一行打印语句并结束了。主协程一退出,整个程序立即终止,后台的子协程也就没有机会运行了。
在前面的几个例子中,为了方便观察结果,我们都是使用 time.Sleep() 让主协程暂停等待。不过在实际开发中,我们很难提前猜准子协程到底需要运行多久,因此一般会配合通道或 WaitGroup 来实现同步等待。
Go 协程与操作系统线程的区别
在其他很多编程语言中,并发任务通常直接交给操作系统的 “线程(Thread)” 来执行。而在 Go 语言中,协程是由 Go 运行时在程序内部自主调度管理的,相比传统线程主要有以下 2 个优势:
- 初始内存占用很小:创建一个传统的操作系统线程,通常需要分配 1MB 到 2MB 的固定栈空间,开启几千个线程就容易耗尽内存。而一个 Go 协程在刚创建时只占用约 2KB 的栈空间,后续还会根据实际需要动态扩缩容。
- 调度切换成本很低:传统线程之间的切换需要经过操作系统内核,耗时较长。而 Go 协程的切换完全在程序内部完成,开销小不少,因此一台普通电脑也能同时运行成千上万个 Go 协程。
