Golang 入门 : goroutine(协程)

在操作系统中,执行体是个抽象的概念。与之对应的实体有进程、线程以及协程(coroutine)。协程也叫轻量级的线程,与传统的进程和线程相比,协程的最大特点是 "轻"!可以轻松创建上百万个协程而不会导致系统资源衰竭。
多数编程语言在语法层面并不直接支持协程,而是通过库的方式支持。但是用库的方式支持的功能往往不是很完整,比如仅仅提供轻量级线程的创建、销毁和切换等能力。如果在这样的协程中调用一个同步 IO 操作,比如网络通信、本地文件读写,都会阻塞其他的并发执行的协程,从而无法达到轻量级线程本身期望达到的目标。

goroutine

Golang 在语言级别支持协程,称之为 goroutine。Golang 标准库提供的所有系统调用操作(包括所有的同步 IO 操作),都会出让 CPU 给其他 goroutine。这让 goroutine 的切换管理不依赖于系统的线程和进程,也不依赖于 CPU 的核心数量,而是交给 Golang 的运行时统一调度。

goroutine 是 Golang 中并发设计的核心,更多关于并发的概念,请参考《Golang 入门 : 理解并发与并行》。 本文接下来的部分着重通过 demo 介绍 goroutine 的用法。

入门 demo

要在一个协程中运行函数,直接在调用函数时添加关键字 go 就可以了:

package main

import (
    "time"
    "fmt"
)

func say(s string) {
    for i := 0; i < 3; i++ {
        time.Sleep(100 * time.Millisecond)
        fmt.Println(s)
    }
}

func main() {
    go say("hello world")
    time.Sleep(1000 * time.Millisecond)
    fmt.Println("over!")
}

执行上面的代码,输出结果为:

hello world
hello world
hello world
over!

至于为什么要在 main 函数中调用 Sleep,如何用优雅的方式代替 Sleep,请参考《Golang 入门 : 等待 goroutine 完成任务》一文。

goroutine 的生命周期

让我们通过下面的 demo 来理解 goroutine 的生命周期:

package main

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

func main() {
    // 分配一个逻辑处理器给调度器使用
    runtime.GOMAXPROCS(1)

    // wg用来等待程序完成
    // 计数加2,表示要等待两个goroutine
    var wg sync.WaitGroup
    wg.Add(2)

    fmt.Println("Start Goroutines")

    // 声明一个匿名函数,并创建一个goroutine
    go func(){
        // 在函数退出时调用Done来通知main函数工作已经完成
        defer wg.Done()

        // 显示字母表3次
        for count := 0; count< 3; count++{
            for char := 'a'; char< 'a'+26; char++{
                fmt.Printf("%c ", char)
            }
            fmt.Println()
        }
    }()
    // 声明一个匿名函数,并创建一个goroutine
    go func(){
        // 在函数退出时调用Done来通知main函数工作已经完成
        defer wg.Done()

        // 显示字母表3次
        for count := 0; count< 3; count++{
            for char := 'A'; char< 'A'+26; char++{
                fmt.Printf("%c ", char)
            }
            fmt.Println()
        }
    }()

    // 等待goroutine结束
    fmt.Println("Waiting To Finish")
    wg.Wait()

    fmt.Println("Terminating Program")
}

在 demo 的起始部分,通过调用 runtime 包中的 GOMAXPROCS 函数,把可以使用的逻辑处理器的数量设置为 1。
接下来通过 goroutine 执行的两个匿名函数分别输出三遍小写字母和三遍大写字母。运行上面代码,输出的结果如下:

Start Goroutines
Waiting To Finish
A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
a b c d e f g h i j k l m n o p q r s t u v w x y z
a b c d e f g h i j k l m n o p q r s t u v w x y z
a b c d e f g h i j k l m n o p q r s t u v w x y z
Terminating Program

第一个 goroutine 完成所有任务的时间太短了,以至于在调度器切换到第二个 goroutine 之前,就完成了所有任务。这也是为什么会看到先输出了所有的大写字母,之后才输出小写字母。我们创建的两个 goroutine 一个接一个地并发运行,独立完成显示字母表的任务。
因为 goroutine 以非阻塞的方式执行,它们会随着程序(主线程)的结束而消亡,所以我们在 main 函数中使用 WaitGroup 来等待两个 goroutine 完成他们的工作,更多 WaitGroup 相关的信息,请参考《Golang 入门 : 等待 goroutine 完成任务》一文。

基于调度器的内部算法,一个正运行的 goroutine 在工作结束前,可以被停止并重新调度。调度器这样做的目的是防止某个 goroutine 长时间占用逻辑处理器。当 goroutine 占用时间过长时,调度器会停止当前正运行的 goroutine,并给其他可运行的 goroutine 运行的机会。
让我们通过下图来理解这一场景(下图来自互联网):

  • 在第 1 步,调度器开始运行 goroutine A,而 goroutine B 在运行队列里等待调度。
  • 在第 2 步,调度器交换了 goroutine A 和 goroutine B。由于 goroutine A 并没有完成工作,因此被放回到运行队列。
  • 在第 3 步,goroutine B 完成了它的工作并被系统销毁。这也让 goroutine A 继续之前的工作。

让我们通过一个运行时间长些的任务来观察该行为,运行下面的 代码:

package main

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

func main() {
    // wg用来等待程序完成
    var wg sync.WaitGroup

    // 分配一个逻辑处理器给调度器使用
    runtime.GOMAXPROCS(1)

    // 计数加2,表示要等待两个goroutine
    wg.Add(2)

    // 创建两个goroutine
    fmt.Println("Create Goroutines")
    go printPrime("A", &wg)
    go printPrime("B", &wg)

    // 等待goroutine结束
    fmt.Println("Waiting To Finish")
    wg.Wait()

    fmt.Println("Terminating Program")
}

// printPrime 显示5000以内的素数值
func printPrime(prefix string, wg *sync.WaitGroup){
    // 在函数退出时调用Done来通知main函数工作已经完成
    defer wg.Done()

next:
    for outer := 2; outer < 5000; outer++ {
        for inner := 2; inner < outer; inner++ {
            if outer % inner == 0 {
                continue next
            }
        }
        fmt.Printf("%s:%d\n", prefix, outer)
    }
    fmt.Println("Completed", prefix)
}

代码中运行了两个 goroutine,分别打印 1-5000 内的素数,输出的结果比较长,精简如下:

Create Goroutines
Waiting To Finish
B:2
B:3
...
B:3851          
A:2             ** 切换 goroutine
A:3
...
A:4297          
B:3853          ** 切换 goroutine
...
B:4999
Completed B
A:4327          ** 切换 goroutine
...
A:4999
Completed A
Terminating Program

上面的输出说明:goroutine B 先执行,然后切换到 goroutine A,再切换到 goroutine B 运行至任务结束,最后又切换到 goroutine A,运行至任务结束。注意,每次运行这个程序,调度器切换的时间点都会稍有不同。

让 goroutine 并行执行

前面的两个示例,通过设置 runtime.GOMAXPROCS(1),强制让 goroutine 在一个逻辑处理器上并发执行。用同样的方式,我们可以设置逻辑处理器的个数等于物理处理器的个数,从而让 goroutine 并行执行(物理处理器的个数得大于 1)。
下面的代码可以让逻辑处理器的个数等于物理处理器的个数:

runtime.GOMAXPROCS(runtime.NumCPU())

其中的函数 NumCPU 返回可以使用的物理处理器的数量。因此,调用 GOMAXPROCS 函数就为每个可用的物理处理器创建一个逻辑处理器。注意,从 Golang 1.5 开始,GOMAXPROCS 的默认值已经等于可以使用的物理处理器的数量了。
修改上面输出素数的程序:

runtime.GOMAXPROCS(2)

因为我们只创建了两个 goroutine,所以逻辑处理器的数量设置为 2 就可以了,重新运行该程序,看看是不是 A 和 B 的输出混合在一起了:

...
B:1741
B:1747
A:241
A:251
B:1753
A:257
A:263
A:269
A:271
A:277
B:1759
A:281
...

除了这个 demo 程序,在真实场景中这种并行的方式会带来很多数据同步的问题。接下来我们将介绍如何来解决数据的同步问题。

参考:
《Go语言实战》

posted @ 2019-05-29 13:01 sparkdev 阅读(...) 评论(...) 编辑 收藏