并发与并行在 Goroutine 中的应用

在 Go 语言中，并发和并行概念常被混淆。尽管它们看起来很相似，但其含义却大相径庭。并发是指同时执行多个任务，而并行则是同时执行多个任务的能力。在本文中，我们将探讨 Go 语言中的并发和并行应用，以及它们之间的区别，特别是如何通过 Goroutine 来实现并发。

一个相当幼稚的问题。我正在学习 go-concurrency 教程，并且遇到了这个 https://tour.golang.org/concurrency/4。

我修改了代码，在斐波那契函数中添加了打印语句。所以代码看起来像这样：

package main

import (
    "fmt"
)

func fibonacci(n int, c chan int) {
    x, y := 0, 1
    for i := 0; i < n; i++ {
        c <- x
        x, y = y, x+y
        fmt.println("here")
    }
    close(c)
}

func main() {
    c := make(chan int, 10)
    go fibonacci(cap(c), c)
    for i := range c {
        fmt.println(i)
    }
}

我得到了这个作为输出

here
here
here
here
here
here
here
here
here
here
0
1
1
2
3
5
8
13
21
34

我原以为 here 和 numbers 会交错。 （因为例程是并发执行的） 我认为我缺少一些有关 go 例程的基本知识。但不太确定是什么。

解决方案

我认为你观察到的是go有自己的调度器，同时“并发”和“并行”之间有区别。用 rob pike 的话说：Concurrency is not Parallelism

goroutines 比操作系统线程轻量得多，并且它们在“用户空间”（go 进程内）而不是操作系统中进行管理。有些程序运行着数千（甚至数万）个 goroutine，而分配的操作系统线程肯定要少得多。 （这是go在具有许多例程的异步程序中的主要优势之一）

因为您的程序非常简单，并且通道已缓冲，所以写入通道时不会阻塞：

c <- x

斐波那契 goroutine 在完成短循环之前不会被抢占。

即使 fmt.println("here") 也没有确定性地引入抢占 - 我在写这个答案时自己学到了一些东西。它已被缓冲，like the analagous printf and scanf from C。 （参见源码https://github.com/golang/go/blob/master/src/fmt/print.go）

有趣的是，如果你想人为地控制操作系统线程的数量，你可以在命令行上设置 gomaxprocs 环境变量：

~$ gomaxprocs=1 go run main.go

但是，对于您的简单程序，可能不会有明显的差异，因为 go 运行时仍然完全能够针对 1 个操作系统线程调度许多 goroutine。 p>

例如，以下是您的程序的一个微小变化。通过使通道缓冲区变小 (5)，但仍迭代 10 次，我们引入了斐波那契 go 例程可以（但不一定）被抢占的点，在该点它至少可以阻塞一旦写入通道：

package main

import (
    "fmt"
)

func fibonacci(n int, c chan int) {
    x, y := 0, 1
    for i := 0; i < n; i++ {
        c <- x
        x, y = y, x+y
        fmt.Println("here")
    }
    close(c)
}

func main() {
    c := make(chan int, 5)
    go fibonacci(cap(c)*2, c)
    for i := range c {
        fmt.Println(i)
    }
}

~$ GOMAXPROCS=1 go run main.go
here
here
here
here
here
here
0
1
1
2
3
5
8
here
here
here
here
13
21
34

Long explanation here，简短的解释是，go 例程可能暂时阻塞的原因有很多，这些是 go 调度程序安排另一个 go 例程执行的理想机会。

这里有一些事情。

1. 您有 2 个 goroutines，一个运行 main()，一个运行 fibonacci()。因为这是一个小程序，所以 go 调度程序没有充分的理由不在同一线程上依次运行它们，所以这就是一致发生的情况，尽管不能保证。因为main()中的goroutine正在等待chan，所以首先调度fibonacci()例程。重要的是要记住 goroutines 不是线程，它们是 go 调度程序根据其喜好在线程上运行的例程。

2. 因为您将缓冲通道的长度传递给 fibonacci() ，所以几乎可以肯定（永远不会依赖此行为）会在之后打印 cap(c) heres channel被填充，for循环结束，close被发送到chan，并且goroutine结束。然后调度 main() goroutine 并打印 cap(c) 斐波那契数。如果缓冲的 chan 已满，则 main() 将被重新安排： https://play.golang.org/p/_IgFIO1K-Dc

3. 通过睡眠，你可以告诉 go 调度程序放弃控制。但实际上永远不要这样做。以某种方式重组，或者，如果必须的话，使用等待组。参见：https://play.golang.org/p/Ln06-NYhQDj

4. 我认为您正在尝试执行此操作：https://play.golang.org/p/8Xo7iCJ8Gj6

今天关于《并发与并行在 Goroutine 中的应用》的内容就介绍到这里了，是不是学起来一目了然！想要了解更多关于的内容请关注golang学习网公众号！