1. Go Goroutine并发执行的挑战
在go语言中，goroutine是轻量级的并发执行单元。开发者通常期望启动多个goroutine后，它们能够独立并行运行，尤其是当任务负载不同时，轻量级任务应更快完成。然而，实际观察到的行为有时并非如此，例如，多个goroutine在处理不同大小的数据集时，其“完成”消息可能几乎同时出现，这让人误以为它们在相互等待。
考虑以下冒泡排序的例子，其中启动了三个goroutine，分别对不同大小的切片进行排序：
package main
import (
"fmt"
"math/rand"
"time"
)
/* 简单的冒泡排序算法 */
func bubblesort(str string, a []int) []int {
for n := len(a); n > 1; n-- {
for i := 0; i < n-1; i++ {
if a[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 done Thread 2 done Thread 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 main
import (
"fmt"
"math/rand"
"runtime" // 导入 runtime 包
"time"
)
/* 简单的冒泡排序算法 */
func bubblesort(str string, a []int) []int {
for n := len(a); n > 1; n-- {
for i := 0; i < n-1; i++ {
if a[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可以真正并行运行。预期输出将反映任务负载的差异：
本文档主要讲述的是用Apache Spark进行大数据处理——第一部分：入门介绍；Apache Spark是一个围绕速度、易用性和复杂分析构建的大数据处理框架。最初在2009年由加州大学伯克利分校的AMPLab开发，并于2010年成为Apache的开源项目之一。 在这个Apache Spark文章系列的第一部分中，我们将了解到什么是Spark，它与典型的MapReduce解决方案的比较以及它如何为大数据处理提供了一套完整的工具。希望本文档会给有需要的朋友带来帮助；感
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的生命周期和同步。
