Goroutine 基于协程 Coroutine，原理总结：

• 如果创建一个 goroutine 并准备运行，这个 goroutine 就会被放到调度器的全局运行队列中。
• 之后，调度器就将这些队列中的 goroutine 分配给一个逻辑处理器，并放到这个逻辑处理器对应的本地运行队列中。
• 本地运行队列中的 goroutine 会一直等待直到自己被分配的逻辑处理器执行

Goroutine 机制原理如下图所示：

image.png

一、最简示例

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 关键字创建 Goroutine

• 匿名函数实现方式 go func() {xxx}()
• 普通函数 funcA 实现方式 go funcA()

二、打断正在运行的 Goroutine

• 基于调度器的内部算法，一个正运行的 goroutine 在工作结束前，可以被停止并重新调度。
• 调度器这样做的目的是防止某个 goroutine 长时间占用逻辑处理器。当 goroutine 占用时间过长时，调度器会停止当前正运行的 goroutine，并给其他可运行的 goroutine 运行的机会。

该机制的原理如下图所示：

image.png

步骤

• 在第 1 步，调度器开始运行 goroutine A，而 goroutine B 在运行队列里等待调度。
• 在第 2 步，调度器交换了 goroutine A 和 goroutine B。 由于 goroutine A 并没有完成工作，因此被放回到运行队列。
• 在第 3 步，goroutine B 完成了它的工作并被系统销毁。这也让 goroutine 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
}

代码执行图：

image.png

五、锁机制

5.1、原子类 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 进入临界区
    }
}