【译】如何使用 Golang 中的 Go-Routines 写出高性能的代码

时间 2019-11-21

原文原文链接

原文地址：How to write high-performance code in Golang using Go-Routines

原文做者：Vignesh Sk

译文出自：掘金翻译计划

本文永久连接：github.com/xitu/gold-m…

译者：tmpbook

校对者：altairlu

如何使用 Golang 中的 Go-Routines 写出高性能的代码

为了用 Golang 写出快速的代码，你须要看一下 Rob Pike 的视频 - Go-Routines。前端

他是 Golang 的做者之一。若是你尚未看过视频，请继续阅读，这篇文章是我对那个视频内容的一些我的看法。我感受视频不是很完整。我猜 Rob 由于时间关系忽略掉了一些他认为不值得讲的观点。不过我花了不少的时间来写了一篇综合全面的关于 go-routines 的文章。我没有涵盖视频中涵盖的全部主题。我会介绍一些本身用来解决 Golang 常见问题的项目。react

好的，为了写出很快的 Golang 程序，有三个概念你须要彻底了解，那就是 Go-Routines，闭包，还有管道。android

Go-Routines

让咱们假设你的任务是将 100 个盒子从一个房间移到另外一个房间。再假设，你一次只能搬一个盒子，并且移动一次会花费一分钟时间。因此，你会花费 100 分钟的时间搬完这 100 个箱子。ios

如今，为了让加快移动 100 个盒子这个过程，你能够找到一个方法更快的移动这个盒子（这相似于找一个更好的算法去解决问题）或者你能够额外雇佣一我的去帮你移动盒子（这相似于增长 CPU 核数用于执行算法）git

这篇文章重点讲第二种方法。编写 go-routines 并利用一个或者多个 CPU 核心去加快应用的执行。github

任何代码块在默认状况下只会使用一个 CPU 核心，除非这个代码块中声明了 go-routines。因此，若是你有一个 70 行的，没有包含 go-routines 的程序。它将会被单个核心执行。就像咱们的例子，一个核心一次只能执行一个指令。所以，若是你想加快应用程序的速度，就必须把全部的 CPU 核心都利用起来。golang

因此，什么是 go-routine。如何在 Golang 中声明它？算法

让咱们看一个简单的程序并介绍其中的 go-routine。编程

示例程序 1

假设移动一个盒子至关于打印一行标准输出。那么，咱们的实例程序中有 10 个打印语句（由于没有使用 for 循环，咱们只移动 10 个盒子）。后端

package main

import "fmt"

func main() {
    fmt.Println("Box 1")
    fmt.Println("Box 2")
    fmt.Println("Box 3")
    fmt.Println("Box 4")
    fmt.Println("Box 5")
    fmt.Println("Box 6")
    fmt.Println("Box 7")
    fmt.Println("Box 8")
    fmt.Println("Box 9")
    fmt.Println("Box 10")
}复制代码

由于 go-routines 没有被声明，上面的代码产生了以下输出。

输出

Box 1
Box 2
Box 3
Box 4
Box 5
Box 6
Box 7
Box 8
Box 9
Box 10复制代码

因此，若是咱们想在在移动盒子这个过程当中使用额外的 CPU 核心，咱们须要声明一个 go-routine。

包含 Go-Routines 的示例程序 2

package main

import "fmt"

func main() {
    go func() {
        fmt.Println("Box 1")
        fmt.Println("Box 2")
        fmt.Println("Box 3")
    }()
    fmt.Println("Box 4")
    fmt.Println("Box 5")
    fmt.Println("Box 6")
    fmt.Println("Box 7")
    fmt.Println("Box 8")
    fmt.Println("Box 9")
    fmt.Println("Box 10")
}复制代码

这儿，一个 go-routine 被声明且包含了前三个打印语句。意思是处理 main 函数的核心只执行 4-10 行的语句。另外一个不一样的核心被分配去执行 1-3 行的语句块。

输出

Box 4
Box 5
Box 6
Box 1
Box 7
Box 8
Box 2
Box 9
Box 3
Box 10复制代码

分析输出

在这段代码中，有两个 CPU 核心同时运行，试图执行他们的任务，而且这两个核心都依赖标准输出来完成它们相应的任务（由于这个示例中咱们使用了 print 语句）
换句话来讲，标准输出（运行在它本身的一个核心上）一次只能接受一个任务。因此，你在这儿看到的是一种随机的排序，这取决于标准输出决定接受 core1 core2 哪一个的任务。

如何声明 go-routine？

为了声明咱们本身的 go-routine，咱们须要作三件事。

咱们建立一个匿名函数
咱们调用这个匿名函数
咱们使用「go」关键字来调用

因此，第一步是采用定义函数的语法，但忽略定义函数名（匿名）来完成的。

func() {
    fmt.Println("Box 1")
    fmt.Println("Box 2")
    fmt.Println("Box 3")
}复制代码

第二步是经过将空括号添加到匿名方法后面来完成的。这是一种叫命名函数的方法。

func() {
  fmt.Println("Box 1")
  fmt.Println("Box 2")
  fmt.Println("Box 3")
} ()复制代码

步骤三能够经过 go 关键字来完成。什么是 go 关键字呢，它能够将功能块声明为能够独立运行的代码块。这样的话，它可让这个代码块被系统上其余空闲的核心所执行。

#细节 1：当 go-routines 的数量比核心数量多的时候会发生什么？

单个核心经过上下文切换并行执行多个go程序来实现多个核心的错觉。

#本身试试之1：试着移除示例程序2中的 go 关键字。输出是什么呢？

答案：示例程序2的结果和1如出一辙。

#本身试试之 2：将匿名函数中的语句从 3 增长至 8 个。结果改变了吗？

答案：是的。main 函数是一个母亲 go-routine（其余全部的 go-routine 都在它里面被声明和建立）。因此，当母亲 go-routine 执行结束，即便其余 go-routines 执行到中途，它们也会被杀掉而后返回。

咱们如今已经知道 go-routines 是什么了。接下来让咱们来看看闭包。

若是以前没有在 Python 或者 JavaScript 中学过闭包，你能够如今在 Golang 中学习它。学到的人能够跳过这部分来节省时间，由于 Golang 中的闭包和 Python 或者 JavaScript 中是同样的。

在咱们深刻理解闭包以前。让咱们先看看不支持闭包属性的语言好比 C，C++ 和 Java，在这些语言中，

函数只访问两种类型的变量，全局变量和局部变量（函数内部的变量）。
没有函数能够访问声明在其余函数里的变量。
一旦函数执行完毕，这个函数中声明的全部变量都会消失。

对 Golang，Python 或者 JavaScript 这些支持闭包属性的语言，以上都是不正确的，缘由在于，这些语言拥有如下的灵活性。

函数能够声明在函数内。
函数能够返回函数。

推论 #1：由于函数能够被声明在函数内部，一个函数声明在另外一个函数内的嵌套链是这种灵活性的常见副产品。

为了了解为何这两个灵活性彻底改变了运做方式，让咱们看看什么是闭包。

因此什么是闭包？

除了访问局部变量和全局变量，函数还能够访问函数声明中声明的全部局部变量，只要它们是在以前声明的（包括在运行时传递给闭包函数的全部参数），在嵌套的状况下，函数能够访问全部函数的变量（不管闭包的级别如何）。

为了理解的更好，让咱们考虑一个简单的状况，两个函数，一个包含另外一个。

package main

import "fmt"

var zero int = 0

func main() {
    var one int = 1
    child := func() {
        var two int = 3
        fmt.Println(zero)
        fmt.Println(one)
        fmt.Println(two)
        fmt.Println(three) // causes compilation Error
    }
    child()
    var three int = 2
}复制代码

这儿有两个函数 - 主函数和子函数，其中子函数定义在主函数中。子函数访问

zero 变量 - 它是全局变量
one 变量 - 闭包属性 - one 属于主函数，它在主函数中且定义在子函数以前。
two 变量 - 它是子函数的局部变量

注意：虽然它被定义在封闭函数「main」中，但它不能访问 three 变量，由于后者的声明在子函数的定义后面。

和嵌套同样。

package main

import "fmt"

var global func()

func closure() {
    var A int = 1
    func() {
        var B int = 2
        func() {
            var C int = 3
            global = func() {
                fmt.Println(A, B, C)
                fmt.Println(D, E, F) // causes compilation error
            }
            var D int = 4
        }()
        var E int = 5
    }()
    var F int = 6
}
func main() {
    closure()
    global()
}复制代码

若是咱们考虑一下将一个最内层的函数关联给一个全局变量「global」。

它能够访问到 A、B、C 变量，和闭包无关。
它没法访问 D、E、F 变量，由于它们以前没有定义。

注意：即便闭包执行完了，它的局部变量任然不会被销毁。它们仍然可以经过名字是「global」的函数名去访问。

下面介绍一下 Channels。

Channels 是 go-routines 之间通讯的一种资源，它们能够是任意类型。

ch := make(chan string)复制代码

咱们定义了一个叫作 ch 的 string 类型的 channel。只有 string 类型的变量能够经过此 channel 通讯。

ch <- "Hi"复制代码

就是这样发送消息到 channel 中。

msg := <- ch复制代码

这是如何从 channel 中接收消息。

全部 channel 中的操做（发送和接收）本质上是阻塞的。这意味着若是一个 go-routine 试图经过 channel 发送一个消息，那么只有在存在另外一个 go-routine 正在试图从 channel 中取消息的时候才会成功。若是没有 go-routine 在 channel 那里等待接收，做为发送方的 go-routine 就会永远尝试发送消息给某个接收方。

最重要的点是这里，跟在 channel 操做后面的全部的语句在 channel 操做结束以前是不会执行的，go-routine 能够解锁本身而后执行跟在它后面的的语句。这有助于同步其余代码块的各类 go-routine。

免责声明：若是只有发送方的 go-routine，没有其余的 go-routine。那么会发生死锁，go 程序会检测出死锁并崩溃。

注意：全部以上讲的也都适用于接收方 go-routines。

缓冲 Channels

ch := make(chan string, 100)复制代码

缓冲 channels 本质上是半阻塞的。

好比，ch 是一个 100 大小的缓冲字符 channel。这意味着前 100 个发送给它的消息是非阻塞的。后面的就会阻塞掉。

这种类型的 channels 的用处在于从它中接收消息以后会再次释放缓冲区，这意味着，若是有 100 个新 go-routines 程序忽然出现，每一个都从 channel 中消费一个消息，那么来自发送者的下 100 个消息将会再次变为非阻塞。

因此，一个缓冲 channel 的行为是否和非缓冲 channel 同样，取决于缓冲区在运行时是否空闲。

Channels 的关闭

close(ch)复制代码

这就是如何关闭 channel。在 Golang 中它对避免死锁颇有帮助。接收方的 go-routine 能够像下面这样探测 channel 是否关闭了。

msg, ok := <- ch
if !ok {
  fmt.Println("Channel closed")
}复制代码

使用 Golang 写出很快的代码

如今咱们讲的知识点已经涵盖了 go-routines，闭包，channel。考虑到移动盒子的算法已经颇有效率，咱们能够开始使用 Golang 开发一个通用的解决方案来解决问题，咱们只关注为任务雇佣合适的人的数量。

让咱们仔细看看咱们的问题，从新定义它。

咱们有 100 个盒子须要从一个房间移动到另外一个房间。须要着重说明的一点是，移动盒子1和移动盒子2涉及的工做没有什么不一样。所以咱们能够定义一个移动盒子的方法，变量「i」表明被移动的盒子。方法叫作「任务」，盒子数量用「N」表示。任何「计算机编程基础 101」课程都会教你如何解决这个问题：写一个 for 循环调用「任务」N 次，这致使计算被单核心占用，而系统中的可用核心是个硬件问题，取决于系统的品牌，型号和设计。因此做为软件开发人员，咱们将硬件从咱们的问题中抽离出去，来讨论 go-routines 而不是核心。越多的核心就支持越多的 go-routines，咱们假设「R」是咱们「X」核心系统所支持的 go-routines 数量。

FYI：数量「X」的核心数量能够处理超过数量「X」的 go-routines。单个核心支持的 go-routines 数量（R/X）取决于 go-routines 涉及的处理方式和运行时所在的平台。好比，若是全部的 go-routine 仅涉及阻塞调用，例如网络 I/O 或者磁盘 I/O，则单个内核足以处理它们。这是真的，由于每一个 go-routine 相比运算来讲更多的在等待。所以，单个核心能够处理全部 go-routine 之间的上下文切换。

所以咱们的问题的通常性的定义为

将「N」个任务分配给「R」个 go-routines，其中全部的任务都相同。

若是 N≤R，咱们能够用如下方式解决。

package main

import "fmt"

var N int = 100

func Task(i int) {
    fmt.Println("Box", i)
}
func main() {
    ack := make(chan bool, N) // Acknowledgement channel
    for i := 0; i < N; i++ {
        go func(arg int) { // Point #1
            Task(arg)
            ack <- true // Point #2
        }(i) // Point #3
    }

    for i := 0; i < N; i++ {
        <-ack // Point #2
    }
}复制代码

解释一下咱们作了什么...

咱们为每一个任务建立一个 go-routine。咱们的系统能同时支持「R」个 go-routines。只要 N≤R 咱们这么作就是安全的。
咱们确认 main 函数在等待全部 go-routine 完成的时候才返回。咱们经过等待全部 go-routine（经过闭包属性）使用的确认 channel（「ack」）来传达其完成。
咱们传递循环计数「i」做为参数「arg」给 go-routine，而不是经过闭包属性在 go-routine 中直接引用它。

另外一方面，若是 N>R，则上述解决方法会有问题。它会建立系统不能处理的 go-routines。全部核心都尝试运行更多的，超过其容量的 go-routines，最终将会把更多的时间话费在上下文切换上而不是运行程序（俗称抖动）。当 N 和 R 之间的数量差别愈来愈大，上下文切换的开销会更加突出。所以要始终将 go-routine 的数量限制为 R。并将 N 个任务分配给 R 个 go-routines。

下面咱们介绍 workers 函数

var R int = 100
func Workers(task func(int)) chan int { // Point #4
 input := make(chan int)                // Point #1
 for i := 0; i < R; i++ {               // Point #1
   go func() {
     for {
       v, ok := <-input                   // Point #2
       if ok {
         task(v)                           // Point #4
       } else {
         return                            // Point #2
       }
     }
   }()
 }
 return input                          // Point #3
}复制代码

建立一个包含有「R」个 go-routines 的池。很少也很多，全部对「input」channel 的监听经过闭包属性来引用。
建立 go-routines，它经过在每次循环中检查 ok 参数来判断 channel 是否关闭，若是 channel 关闭则杀死本身。
返回 input channel 来容许调用者函数分配任务给池。
使用「task」参数来容许调用函数定义 go-routines 的主体。

使用

func main() {
ack := make(chan bool, N)
workers := Workers(func(a int) {     // Point #2
  Task(a)
  ack <- true                        // Point #1
 })
for i := 0; i < N; i++ {
  workers <- i
 }
for i := 0; i < N; i++ {             // Point #3
  <-ack
 }
}复制代码

经过将语句（Point #1）添加到 worker 方法中（Point #2），闭包属性巧妙的在任务参数定义中添加了对确认 channel 的调用，咱们使用这个循环（Point #3）来使 main 函数有一个机制去知道池中的全部 go-routine 是否都完成了任务。全部和 go-routines 相关的逻辑都应该包含在 worker 本身中，由于它们是在其中建立的。main 函数不该该知道内部 worker 函数们的工做细节。

所以，为了实现彻底的抽象，咱们要引入一个『climax』函数，只有在池中全部 go-routine 所有完成以后才运行。这是经过设置另外一个单独检查池状态的 go-routine 来实现的，另外不一样的问题须要不一样类型的 channel 类型。相同的 int cannel 不能在全部状况下使用，因此，为了写一个更通用的 worker 函数，咱们将使用空接口类型从新定义一个 worker 函数。

package main

import "fmt"

var N int = 100
var R int = 100

func Task(i int) {
    fmt.Println("Box", i)
}
func Workers(task func(interface{}), climax func()) chan interface{} {
    input := make(chan interface{})
    ack := make(chan bool)
    for i := 0; i < R; i++ {
        go func() {
            for {
                v, ok := <-input
                if ok {
                    task(v)
                    ack <- true
                } else {
                    return
                }
            }
        }()
    }
    go func() {
        for i := 0; i < R; i++ {
            <-ack
        }
        climax()
    }()
    return input
}
func main() {

    exit := make(chan bool)

    workers := Workers(func(a interface{}) {
        Task(a.(int))
    }, func() {
        exit <- true
    })

    for i := 0; i < N; i++ {
        workers <- i
    }
    close(workers)

    <-exit
}复制代码

你看，我已经试图展现了 Golang 的力量。咱们还研究了如何在 Golang 中编写高性能代码。

请观看 Rob Pike 的 Go-Routines 视频，而后和 Golang 度过一个美好的时光。

直到下次...

感谢 Prateek Nischal。

掘金翻译计划是一个翻译优质互联网技术文章的社区，文章来源为掘金上的英文分享文章。内容覆盖 Android、iOS、React、前端、后端、产品、设计等领域，想要查看更多优质译文请持续关注掘金翻译计划、官方微博、知乎专栏。