hello world 的并发实现

---

本篇文章将介绍 hello world 的并发实现，其中涉及到的知识有:

• 并发与并行
• GPM 调度系统

并发与并行

并发不是并行。并发是同时管理很多事情，这些事情可能只做了一半就被暂停做别的事情了。而并行是同时做很多事情，让不同的代码段同时在不同的物理处理器上执行。

在很多情况下，并发要比并行好，它符合 Go 语言的涉及哲学: 使用较少的资源做更多的事情。

Go 的 GPM 调度系统

GPM 是 Go 自己实现的一套调度系统，区别于操作系统层面的线程调度系统。

• G 是 Goroutine 的缩写，goroutine 相当于操作系统的进程控制块，它是一个独立的工作单元。
• P(Processor) 是一个抽象的概念，并不是真正的 CPU，它管理着一组 goroutine 队列(暂停占用较长 CPU 时间的 goroutine,运行等待的 goroutine 等)，当管理的 goroutine 队列都执行完则从全局队列里取任务，如果全局队列也没有任务，则去其它 P 的队列里抢任务。
• M(Machine) 是 Go 运行时(runtime) 对操作系统内核线程的虚拟，M 与内核线程是一一映射的关系(M 和 P 一般也是一一对应)，一个 goroutine 最终要调度到 M 上执行。

1. hello world 的并发实现

package main

import (
	"fmt"
	"runtime"
    "sync"
)

var wg sync.WaitGroup

func say_hello(value interface{}) {
	defer wg.Done()
	fmt.Printf("%v", value)
}

func common_say_hello() {
	wg.Add(5)
	go say_hello("w")
	go say_hello("o")
	go say_hello("r")
	go say_hello("l")
	go say_hello("d")
}

func main() {
	runtime.GOMAXPROCS(1)
	common_say_hello()
	wg.Wait()
}

代码介绍:

• runtime 包的 GOMAXPROCS 函数允许程序更改调度器可以使用的逻辑处理器数量，逻辑处理器和操作系统线程是一一绑定的关系。这里仅使用 1 个逻辑处理器处理并发运行的 goroutine。
• 实现 goroutine 很简单只需要在函数名前加 go 即可让该函数独立于其它函数运行，Go 会将其视为一个独立的工作单元，这个单元会被调度到可用的逻辑处理器上执行。
• 使用 sync 包结构体 WaitGroup 的 Add/Wait/Done 方法来等待 goroutine 的完成。如果不加等待， main 函数会在 goroutine 运行前终止。

代码运行结果如下:

dworl

为什么 d 会打印在最前面而 worl 则依次打印呢？

<<Go 语言实战>> 给出的解释是“第一个 goroutine 完成所有显示需要花的时间很短，以至于调度器切换到第二个 goroutine之前就完成了所有任务”。那么，这里的第一个 goroutine 是 “go say_hello("d")” 吗？第二个，第三个 goroutine.. 又是哪个呢？调度器根据怎么的顺序来调度 goroutine 呢？这些问题留给我们后续解答，有知道的朋友还请不吝赐教，感谢。

上面的代码限定了逻辑处理器的数量为 1，所以这里其实实现的是并发而不是并行。当设置逻辑处理器的数量大于 1 时，即实现了并行也实现了并发。更改逻辑处理器数量为 3，查看程序运行情况:

dorlw
dowlr
ldorw

执行了三次每次打印的输出都不一样。

那么是不是到这里就结束了呢？没有。有一点需要说明的是: 一个正在运行的 goroutine 可以被停止并重新调度。如果 goroutine 长时间占用逻辑处理器，调度器会停止该 goroutine，并给其它 goroutine 运行的机会。

基于上述分析，更改 hello world 代码，使每个 goroutine 占用较长的逻辑处理器时间，查看 goroutine 是否被调度器切换，代码如下:

func multi_hello(prefix string) {
	defer wg.Done()

next:
	for outer := 2; outer < 5000; outer++ {
		for inter := 2; inter < outer; inter++ {
			if outer%inter == 0 {
				continue next
			}
		}
		fmt.Println("say %s: %d times", prefix, outer)
	}
}

func crazy_say_hello() {
	wg.Add(5)
	go multi_hello("w")
	go multi_hello("o")
	go multi_hello("r")
	go multi_hello("l")
	go multi_hello("d")
}

func main() {
	runtime.GOMAXPROCS(1)
	crazy_say_hello()
	wg.Wait()
}

查看代码执行结果:

say r: 4327 times
say r: 4337 times
say r: 4339 times
say w: 4493 times
say w: 4507 times
say w: 4513 times
...
say w: 4999 times
say r: 4349 times
say r: 4357 times
...

这里仅截取部分执行结果。可以看到，执行 r goroutine 第 4349 次的时候调度器切换 “r goroutine” 到 “w goroutine” ，然后执行 w goroutine 4999 次的时候调度再切换回 “r goroutine”。

上述 hello world 的 goroutine 均不涉及对共享资源的访问，因此它们能和谐共存，互不干扰。如果涉及到共享资源的访问，goroutine 将变得相当“野蛮”也即出现相互竞争访问共享资源的状态，这种情况称为“竞争”状态。

2. 竞争状态的 goroutine

进一步改写 hello world 程序如下:

var helloTimes int32

func cal_hello_num(prefix string) {
	defer wg.Done()

	value := helloTimes
	runtime.Gosched()

	value++
	helloTimes = value
	fmt.Printf("say %s: %d times\n", prefix, helloTimes)
}

func num_say_hello() {
	wg.Add(5)
	go cal_hello_num("w")
	go cal_hello_num("o")
	go cal_hello_num("r")
	go cal_hello_num("l")
	go cal_hello_num("d")
}

func main() {
	runtime.GOMAXPROCS(1)
	num_say_hello()
	wg.Wait()
}

为方便说明这里将逻辑处理器的数量设为 1，同时引入 runtime 包的 Gosched 函数，该函数会将当前 goroutine 从线程退出，并放回到逻辑处理器的队列中。程序执行结果如下:

say d: 1 times
say w: 1 times
say o: 1 times
say r: 1 times
say l: 1 times

多次执行，每个 goroutine 打印结果均为 1，为什么呢？

分析上述代码，每个 goroutine 都会覆盖另一个 goroutine 的工作(竞争状态因此存在)。每个 goroutine 均创造了变量 helloTimes 的副本 value，当 goroutine 切换时，每个 goroutine 会将自己维护的 value 赋值给 helloTimes，导致 helloTimes 的值一直是 1。

那么，如果每个 goroutine 都不创造变量的副本是否这种竞争状态就消失了呢？

进一步改写程序如下:

改写版本1

func cal_hello_num(prefix string) {
	defer wg.Done()

	helloTimes++
	runtime.Gosched()
	fmt.Printf("say %s: %d times\n", prefix, helloTimes)
}

// 运行结果
say d: 5 times
say w: 5 times
say o: 5 times
say r: 5 times
say l: 5 times

改写版本 2

func cal_hello_num(prefix string) {
	defer wg.Done()

	runtime.Gosched()
	helloTimes++
	fmt.Printf("say %s: %d times\n", prefix, helloTimes)
}

// 运行结果
say d: 1 times
say w: 2 times
say o: 3 times
say r: 4 times
say l: 5 times

版本 1 和版本 2 移动了 helloTimes++ 相对于 GoSched 的位置，却得到了完全不同的结果。

其实不难理解，因为 helloTimes 是全局变量，每个 goroutine 都维护这个变量。所以，在版本一中每个 goroutine 切换之前都会对全局变量 helloTimes 加 1，加 1 完成后，程序依次打印“最终值” 5。而版本二 goroutine 在切换之后对全局变量加 1，其效果相当于每个 goroutine 按顺序依次执行全局变量的自增操作。

多个 goroutine 访问共享资源极易出现“幺蛾子”，在程序中可以通过锁住共享资源的方式来避免竞争状态的出现。

3. 锁住共享资源

通过原子函数，互斥锁锁住共享资源，实现 goroutine 对共享资源的顺序访问。

3.1 原子函数

import (
	"fmt"
	"runtime"
	"sync"
	"sync/atomic"
)

func cal_hello_num(prefix string) {
	defer wg.Done()

	atomic.AddInt32(&helloTimes, 1)
	fmt.Printf("say %s: %d times\n", prefix, helloTimes)
}

使用 atomic 包导入原子函数 AddInt32 实现变量 helloTimes 的自增操作。执行结果如下:

say d: 1 times
say w: 2 times
say o: 3 times
say r: 4 times
say l: 5 times

3.2 互斥锁

使用互斥锁防止竞争状态的发生。互斥锁会在代码上创建临界区，保证同一时间只有一个 goroutine 可以访问执行临界区代码。代码如下:

var (
	wg    sync.WaitGroup
	mutex sync.Mutex
)

func cal_hello_num(prefix string) {
	defer wg.Done()
	mutex.Lock() 

	value := helloTimes
	runtime.Gosched()
	value++
	helloTimes = value
	fmt.Printf("say %s: %d times\n", prefix, helloTimes)

	mutex.Unlock()
}

有一点要注意的是: 使用 Gosched 强制 goroutine 退出当前线程后，调度器会再次分配这个 goroutine 继续运行临界区代码。程序执行结果如下:

say d: 1 times
say w: 2 times
say o: 3 times
say r: 4 times
say l: 5 times

再次强调 value 的位置是很关键的，如果对 value := helloTimes 不加锁，每个 goroutine 还是会保留各自的副本，起不到防止竞争状态的作用。代码及执行结果如下所示:

func cal_hello_num(prefix string) {
	defer wg.Done()

	value := helloTimes
	mutex.Lock()
	runtime.Gosched()
	value++
	helloTimes = value
	fmt.Printf("say %s: %d times\n", prefix, helloTimes)
	mutex.Unlock()
}

// 执行结果
say d: 1 times
say w: 1 times
say o: 1 times
say r: 1 times
say l: 1 times

当然，除了原子函数和互斥锁防止竞争状态外，还可以使用 channel 通道，channel 通过发送和接收需要共享的资源，实现共享资源在 goroutine 之间的同步。下节将介绍 Go 的 channel 类型以及如何避免掉入 channel 的坑。