本文深入探讨Go语言中goroutine的并发执行机制，特别是当goroutine数量多于默认处理器核心数时，如何通过runtime.GOMAXPROCS确保任务在多核CPU上实现真正的并行处理。文章通过冒泡排序示例，解释了goroutine看似同步完成的现象，并指导如何配置运行时参数以优化并行性能，实现预期的独立任务加速。
1. Go Goroutine并发执行的挑战
在go语言中，goroutine是轻量级的并发执行单元。开发者通常期望启动多个goroutine后，它们能够独立并行运行，尤其是当任务负载不同时，轻量级任务应更快完成。然而，实际观察到的行为有时并非如此，例如，多个goroutine在处理不同大小的数据集时，其“完成”消息可能几乎同时出现，这让人误以为它们在相互等待。
考虑以下冒泡排序的例子，其中启动了三个goroutine，分别对不同大小的切片进行排序：
package mainimport ( "fmt" "math/rand" "time")/* 简单的冒泡排序算法 */func bubblesort(str string, a []int) []int { for n := len(a); n > 1; n-- { for i := 0; i a[i+1] { a[i], a[i+1] = a[i+1], a[i] // 交换 } } } fmt.Println(str + " done") // 完成消息 return a}/* 用伪随机数填充切片 */func random_fill(a []int) []int { for i := 0; i < len(a); i++ { a[i] = rand.Int() } return a}func main() { rand.Seed(time.Now().UTC().UnixNano()) // 设置随机数种子 a1 := make([]int, 34589) // 创建切片 a2 := make([]int, 42) // 创建切片 a3 := make([]int, 9999) // 创建切片 a1 = random_fill(a1) // 填充切片 a2 = random_fill(a2) // 填充切片 a3 = random_fill(a3) // 填充切片 fmt.Println("Slices filled ...") go bubblesort("Thread 1", a1) // 1. Goroutine 启动 go bubblesort("Thread 2", a2) // 2. Goroutine 启动 go bubblesort("Thread 3", a3) // 3. Goroutine 启动 fmt.Println("Main working ...") time.Sleep(1 * time.Minute) // 等待1分钟以接收"done"消息}
在某些环境下运行上述代码，可能会得到如下输出：
Slices filled ...Main working ...Thread 1 doneThread 2 doneThread 3 done
尽管 a2 切片最小（42个元素），a3 次之（9999个元素），a1 最大（34589个元素），但“done”消息却几乎同时出现，或者顺序不确定，且不总是反映任务的实际完成时间。这并非goroutine在相互等待，而是Go运行时调度器在默认配置下，可能没有充分利用多核CPU的并行能力。
2. Go调度器与GOMAXPROCS
Go语言的并发模型是基于M:N调度器实现的，它将M个goroutine调度到N个操作系统线程上执行。默认情况下，Go运行时会尝试利用所有可用的CPU核心。然而，在Go 1.5版本之前，runtime.GOMAXPROCS 的默认值是1，这意味着Go程序在任何给定时刻最多只能有一个操作系统线程在执行Go代码，即使系统有多个CPU核心，goroutine也只能通过时间片轮转的方式并发执行，而非真正的并行。
要强制Go运行时在多个CPU核心上并行执行goroutine，需要显式地设置 runtime.GOMAXPROCS。这个函数用于设置可以同时执行Go代码的操作系统线程的最大数量。
3. 实现真正的并行：配置GOMAXPROCS
为了让Go程序充分利用多核CPU，实现goroutine的真正并行，可以在 main 函数的开头调用 runtime.GOMAXPROCS。
package mainimport ( "fmt" "math/rand" "runtime" // 导入 runtime 包 "time")/* 简单的冒泡排序算法 */func bubblesort(str string, a []int) []int { for n := len(a); n > 1; n-- { for i := 0; i a[i+1] { a[i], a[i+1] = a[i+1], a[i] // 交换 } } } fmt.Println(str + " done") // 完成消息 return a}/* 用伪随机数填充切片 */func random_fill(a []int) []int { for i := 0; i < len(a); i++ { a[i] = rand.Int() } return a}func main() { // 设置 Go 运行时可以使用的最大操作系统线程数 // 这里设置为2，表示最多两个OS线程可以同时执行Go代码 // 也可以设置为 runtime.NumCPU() 来使用所有可用的CPU核心 runtime.GOMAXPROCS(2) rand.Seed(time.Now().UTC().UnixNano()) // 设置随机数种子 a1 := make([]int, 34589) // 创建切片 a2 := make([]int, 42) // 创建切片 a3 := make([]int, 9999) // 创建切片 a1 = random_fill(a1) // 填充切片 a2 = random_fill(a2) // 填充切片 a3 = random_fill(a3) // 填充切片 fmt.Println("Slices filled ...") go bubblesort("Thread 1", a1) // 1. Goroutine 启动 go bubblesort("Thread 2", a2) // 2. Goroutine 启动 go bubblesort("Thread 3", a3) // 3. Goroutine 启动 fmt.Println("Main working ...") time.Sleep(1 * time.Minute) // 等待1分钟以接收"done"消息}
修改后的代码，在执行时，由于 runtime.GOMAXPROCS(2) 的设置，Go调度器现在可以同时在两个操作系统线程上执行goroutine。这意味着，如果系统有至少两个核心，那么两个goroutine可以真正并行运行。预期输出将反映任务负载的差异：
Slices filled ...Main working ...Thread 2 done // 最小的切片最先完成Thread 3 done // 中等大小的切片次之Thread 1 done // 最大的切片最后完成
4. 注意事项与最佳实践
runtime.GOMAXPROCS 的默认值：
在 Go 1.5及更高版本中，runtime.GOMAXPROCS 的默认值已更改为 runtime.NumCPU()，即默认情况下Go程序会尝试使用所有可用的CPU核心进行并行处理。因此，对于新版本的Go，通常无需显式设置 runtime.GOMAXPROCS 就能获得并行优势。如果您的Go版本较老（低于1.5），或者您希望限制Go运行时使用的核心数量，那么显式调用 runtime.GOMAXPROCS 仍然是必要的。
选择 GOMAXPROCS 的值：
通常，将其设置为 runtime.NumCPU() 是一个好的实践，这样Go程序就能充分利用机器的所有物理核心。在某些特定场景下，例如，当程序同时执行大量I/O操作（I/O密集型）时，GOMAXPROCS 的值可能需要根据实际情况进行调整，甚至可以略大于 runtime.NumCPU()，以允许在等待I/O时调度器切换到其他goroutine。然而，对于CPU密集型任务，通常不建议将其设置得远大于核心数，因为过多的OS线程切换会引入额外的开销。
Goroutine的调度顺序：
即使设置了 runtime.GOMAXPROCS，Go调度器对goroutine的执行顺序仍然不提供任何保证。上述示例中，Thread 2 最先完成是因为其任务量最小，而不是因为调度器优先选择了它。如果需要控制goroutine的执行顺序或等待所有goroutine完成，应使用 sync.WaitGroup、channel 等并发原语，而不是依赖 time.Sleep 这种粗糙的等待方式。
time.Sleep 的副作用：
在 bubblesort 函数中添加 time.Sleep(1) 会强制调度器进行上下文切换，从而可能使小任务在等待时让出CPU给其他goroutine，导致看起来任务是并行完成的。但这会引入不必要的延迟，并不能真实反映算法的执行效率。
总结
理解Go语言的并发模型和调度器行为对于编写高性能的并发程序至关重要。通过正确配置 runtime.GOMAXPROCS（尤其是在Go 1.5之前的版本或需要特定控制的场景），我们可以确保Go程序能够充分利用多核CPU的并行能力，从而让goroutine在独立任务中真正实现并行加速，并获得预期的性能表现。同时，应结合 sync.WaitGroup 等工具，更优雅地管理goroutine的生命周期和同步。
以上就是Go Goroutine并发：理解与启用真正的并行处理的详细内容，更多请关注创想鸟其它相关文章！
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 chuangxiangniao@163.com 举报，一经查实，本站将立刻删除。
发布者：程序猿，转转请注明出处：https://www.chuangxiangniao.com/p/1408921.html
微信扫一扫 
支付宝扫一扫 
