Goroutine 从未在 Linux 上执行，但在 Windows 上正常工作

Question

我是 Go 新手。 google 小时后仍然找不到这个问题的解释。运行下面的代码通常在 Windows 上。它运行:

它会永远等待，但是相同的代码在 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")
}

环境：LinuxUbuntu，go1.10.3linux/amd64

Answer 1

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

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

Playground example

但是你不能依赖go例程的顺序。这是随机的。您还需要注意的一件事是，如果您删除 for 循环，则 main 将在您的 go 例程 return 结果之前退出。

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")
}

输出

在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()
}

输出

Go playground

上的工作代码

Answer 2

我相信，如果您在 for 循环（甚至睡眠）中添加打印语句，您最终会看到 2A 被打印出来。

Go 例程不一定映射到不同的 CPU。而且，当它们都被赋值给同一个CPU时，执行只会在某些库调用（例如Println）时被中断。

Answer 3

有一个简单的解释。它与操作系统无关。 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 可以继续运行。使用的内核数由 GOMAXPROCs 控制，最多可用 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 调度程序运行 main 和 2A goroutines。

$ env GOMAXPROCS=2 go run cores.go
NumCPU:     4
GOMAXPROCS: 2
0
2
3
2A
^Csignal: interrupt
$

现在，让我们在自旋循环之前用 Gosched() 交出主协程，让其他协程有机会运行。

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 goroutines 运行。

$ env GOMAXPROCS=1 go run gosched.go
NumCPU:     4
GOMAXPROCS: 1
0
2
3
2A
^Csignal: interrupt
$

共享两个核心，主程序和2A程序运行。

$ env GOMAXPROCS=2 go run gosched.go
NumCPU:     4
GOMAXPROCS: 2
0
2
3
2A
^Csignal: interrupt
$

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

Goroutine 从未在 Linux 上执行，但在 Windows 上正常工作

Goroutine never executed on Linux but work normally on Windows

go

goroutine