Go routine 基于协程 Coroutine，原理总结：
如果创建一个 goroutine 并准备运行，这个 goroutine 就会被放到调度器的全局运行队列中。之后，调度器就将这些队列中的 goroutine 分配给一个逻辑处理器，并放到这个逻辑处理器对应的本地运行队列中。本地运行队列中的 goroutine 会一直等待直到自己被分配的逻辑处理器执行。
Go routine 机制原理如下图所示：
一、示例
import (
"runtime"
"sync"
"fmt"
)
func main() {
// 1. 分配一个逻辑处理器给调度器使用
runtime.GOMAXPROCS(1)
// 2. 设定等待器，类比 Java CountDownLatch
var waitGroup sync.WaitGroup
waitGroup.Add(2)
fmt.Println("=== start ===")
// 3. 创建第一个 goroutine
go func() {
defer waitGroup.Done() // CountDownLatch#countDown()
// 打印3遍字母表
for count := 0; count < 3; count++ {
for char := 'a'; char < 'a'+26; char++ {
fmt.Printf("%c", char)
}
}
}()
// 4. 创建第二个 goroutine
go func() {
defer waitGroup.Done() // CountDownLatch#countDown()
// 打印3遍字母表
for count := 0; count < 3; count++ {
for char := 'A'; char < 'A'+26; char++ {
fmt.Printf("%c", char)
}
}
}()
// 5. 阻塞 main goroutine
waitGroup.Wait() // CountDownLatch#await()
fmt.Println("=== end ===")
}
使用 go 关键字创建 Go routine
- 匿名函数实现方式 go func() {xxx}()
- 普通函数 funcA 实现方式 go funcA()
二、打断正在运行的 Go routine
- 基于调度器的内部算法，一个正运行的 go routine 在工作结束前，可以被停止并重新调度。
- 调度器这样做的目的是防止某个 go routine 长时间占用逻辑处理器。当 go routine 占用时间过长时，调度器会停止当前正运行的 go routine，并给其他可运行的 go routine 运行的机会。
该机制的原理如下图所示：
步骤：
- 在第 1 步，调度器开始运行 go routine A，而 go routine B 在运行队列里等待调度。
- 在第 2 步，调度器交换了 go routine A 和 go routine B。 由于 go routine A 并没有完成工作，因此被放回到运行队列。
- 在第 3 步，go routine B 完成了它的工作并被系统销毁。这也让 go routine A 继续之前的工作。
注意：上述步骤都是由调度器内部实现的，我们不需要编写代码去实现。
三、设置逻辑处理器数量
// 为每个物理处理器分配一个逻辑处理器给调度器使用
runtime.GOMAXPROCS(runtime.NumCPU())
四、竞争状态
如果两个或者多个 goroutine 在没有互相同步的情况下，访问某个共享的资源，并试图同时读和写这个资源，就处于相互竞争的状态，这种情况被称作竞争状态(race candition)。
同一时刻只能有一个 goroutine 对共享资源进行读和写操作
import (
"runtime"
"sync"
"fmt"
)
var (
// 两个 goroutine 同时操作的变量，竞态变量
counter int
waitGroup sync.WaitGroup
)
func incCount(int) {
defer waitGroup.Done()
for count := 0; count < 2; count++ {
value := counter
// 当前的 goroutine 主动让出资源，从线程退出，并放回到队列，
// 让其他 goroutine 进行执行
runtime.Gosched()
value ++
counter = value
}
}
func main() {
runtime.GOMAXPROCS(1)
waitGroup.Add(2)
go incCount(1)
go incCount(2)
waitGroup.Wait()
fmt.Println(counter) // 正确为4，实际上为2
}
代码执行图:
五、锁机制
5.1、原子类 atomic
import (
"runtime"
"sync/atomic"
)
func incCount(int) {
defer waitGroup.Done()
for count := 0; count < 2; count++ {
// 使用原子类
atomic.AddInt64(&counter, 1)
runtime.Gosched()
}
}
另外两个有用的原子函数是 LoadInt64 和 StoreInt64。这两个函数提供了一种安全地读和写一个整型值的方式
import (
"sync"
"time"
"sync/atomic"
"fmt"
)
var (
shutdown int64
waitGroup sync.WaitGroup
)
func doWork(name string) {
defer waitGroup.Done()
for {
time.Sleep(250 * time.Millisecond)
// 记载关机标志
if atomic.LoadInt64(&shutdown) == 1 {
fmt.Println("shutDown, ", name)
break
}
}
}
func main() {
waitGroup.Add(2)
go doWork("A")
go doWork("B")
// 给定goroutine执行的时间
time.Sleep(1000 * time.Millisecond)
// 设定关机标志
atomic.StoreInt64(&shutdown, 1)
waitGroup.Wait()
}
5.2、互斥锁 mutex
互斥锁用于在代码上创建一个临界区，保证同一时间只有一个 goroutine 可以 执行这个临界区代码
var (
// 两个 goroutine 同时操作的变量，竞态变量
counter int
waitGroup sync.WaitGroup
// 锁，定义一段临界区
lock sync.Mutex
)
func incCount(int) {
defer waitGroup.Done()
for count := 0; count < 2; count++ {
lock.Lock()
{ // Lock() 与 UnLock() 之间的代码都属于临界区，{}是可以省略的，加上看起来清晰
value := counter
// 当前的 goroutine 主动让出资源，从线程退出，并放回到队列，
// 让其他 goroutine 进行执行
// 但是因为锁没有释放，调度器还会继续安排执行该 goroutine
runtime.Gosched()
value ++
counter = value
}
lock.Unlock()
// 释放锁，允许其他正在等待的 goroutine 进入临界区
}
}
近期评论