Goroutine 在 Linux 和 Windows 上表现不一致

在 Linux 和 Windows 系统上运行的 Go 代码表现出差异：在 Windows 上，代码正常运行，但相同代码在 Linux 上无法执行协程。原因在于 Go 调度程序的行为与操作系统无关，在 Linux 和 Windows 上都是一致的。问题源自代码中包含一个自旋锁循环，导致主协程在 Linux 系统上占用一个内核，而其他协程无法运行。通过使用 `gosched()` 放弃主协程，可以在 Linux 上解决该问题，从而为其他协程提供运行机会。

我是 go 新手。经过几个小时的谷歌仍然找不到这个问题的解释。 下面的代码在 windows 上可以正常运行。 它运行：

0
2
3
2a

它会永远等待，但相同的代码在 linux (ubuntu) 上不起作用，goroutine 从未执行：

0
2
3

它会永远等待。

package main

import ("fmt")
var exit bool=false

func main(){
   fmt.Println("0")
   fmt.Println("2")
   go func() {
      fmt.Println("2A");
   }()
   fmt.Println("3")
   for {
        if exit {
           break
        }
   }
   fmt.Println("4")
}

环境：linux ubuntu、go1.10.3 linux/amd64

解决方案

有一个简单的解释。它与操作系统无关。 linux 和 windows 上的行为是相同的。

$ go version
go version devel +f2ed3e1da1 sat aug 25 18:36:22 2018 +0000 linux/amd64
$

>go version
go version devel +e03220a594 sat aug 25 02:39:49 2018 +0000 windows/amd64
>

main goroutine 在遇到忙等待自旋循环时将有效停止：

for {
    if exit {
        break
    }
}

如果我们只使用一个核心，那么整个程序将停止。否则，其他 goroutine 可以继续运行。使用的核心数量由 gomaxproc 控制，最多可达可用的最大 numcpu。

cores.go：

package main

import (
    "fmt"
    "runtime"
)

var exit bool = false

func main() {
    fmt.println("numcpu:    ", runtime.numcpu())
    if runtime.gomaxprocs(0) > runtime.numcpu() {
        runtime.gomaxprocs(runtime.numcpu())
    }
    fmt.println("gomaxprocs:", runtime.gomaxprocs(0))

    fmt.println("0")
    fmt.println("2")
    go func() {
        fmt.println("2a")
    }()
    fmt.println("3")
    for {
        if exit {
            break
        }
    }
    fmt.println("4")
}

go 调度程序使用一个核心来运行主 goroutine。它没有机会运行 2a goroutine。

$ env gomaxprocs=1 go run cores.go
numcpu:     4
gomaxprocs: 1
0
2
3
^csignal: interrupt
$

go 调度程序使用多个内核来运行主协程和 2a 协程。

$ env gomaxprocs=2 go run cores.go
numcpu:     4
gomaxprocs: 2
0
2
3
2a
^csignal: interrupt
$

现在，让我们在自旋循环之前使用 gosched() 放弃主 goroutine，以便为其他 goroutine 有机会运行。

gosched.go：

package main

import (
    "fmt"
    "runtime"
)

var exit bool = false

func main() {
    fmt.println("numcpu:    ", runtime.numcpu())
    if runtime.gomaxprocs(0) > runtime.numcpu() {
        runtime.gomaxprocs(runtime.numcpu())
    }
    fmt.println("gomaxprocs:", runtime.gomaxprocs(0))

    fmt.println("0")
    fmt.println("2")
    go func() {
        fmt.println("2a")
    }()
    fmt.println("3")
    runtime.gosched()
    for {
        if exit {
            break
        }
    }
    fmt.println("4")
}

共享一个核心，运行主协程和 2a 协程。

$ env gomaxprocs=1 go run gosched.go
numcpu:     4
gomaxprocs: 1
0
2
3
2a
^csignal: interrupt
$

共享两个核心，主 gooutine 和 2a gooutine 运行。

$ env gomaxprocs=2 go run gosched.go
numcpu:     4
gomaxprocs: 2
0
2
3
2a
^csignal: interrupt
$

注意：随着 go 运行时的改进，go 调度程序的行为可能会发生变化。例如，可能不允许自旋锁独占一个核心。

尝试在 go 演示上运行相同的程序。它将显示由于永无休止的 for 循环，该过程花费了很长时间。

for { // it is never ending for loop which never exit.
     if exit {
         break
     }
}

Playground example

但是你不能依赖 go 例程的顺序。它是随机的。另外你需要注意的一件事是，如果你删除 for 循环，main 将在你的 go 例程返回结果之前退出。

package main

import (
    "fmt"
)

var exit bool = false

func main() {
    fmt.println("0")
    fmt.println("2")
    go func() {
        fmt.println("2a")
    }()
    fmt.println("3")
    fmt.println("4")
}

输出

0
2
3
4

拨打Playground查看

作为建议，在您想要等待 go 例程在主退出之前完成的情况下，最好使用等待组。举个例子。

package main

import (
    "fmt"
    "sync"
)

var wg sync.waitgroup

var exit bool = false

func main() {
    fmt.println("0")
    fmt.println("2")
    wg.add(1)
    go func() {
        defer wg.done()
        fmt.println("2a")
    }()
    fmt.println("3")
    fmt.println("4")
    wg.wait()
}

输出

0
2
3
4
2A

Go playground 上的工作代码

以上就是本文的全部内容了，是否有顺利帮助你解决问题？若是能给你带来学习上的帮助，请大家多多支持golang学习网！更多关于Golang的相关知识，也可关注golang学习网公众号。