函数

runtime 调度器是个非常有用的东西，关于 runtime 包几个方法:

  • NumCPU：返回当前系统的 CPU 核数量。

  • GOMAXPROCS：设置最大的可同时使用的 CPU 核数。

    • 通过runtime.GOMAXPROCS函数，应用程序何以在运行期间设置运行时系统中的P最大数量。但这会引起“Stop the World”。
    • 所以，应在应用程序最早的调用。并且最好是在运行Go程序之前设置好操作程序的环境变量GOMAXPROCS，而不是在程序中调用runtime.GOMAXPROCS函数。
    • 无论我们传递给函数的整数值是什么值，运行时系统的P最大值总会在1~256之间。

  • Gosched：让当前goroutine让出CPU，好让其它的goroutine获得执行的机会。同时，当前的goroutine也会在未来的某个时间点继续运行。

  • Goexit：退出当前 goroutine。(但是defer语句会照常执行)

  • NumGoroutine：返回正在执行和排队的任务总数

    • runtime.NumGoroutine函数在被调用后，会返回系统中的处于特定状态的Goroutine的数量。
    • 这里的特指是指Grunnable\Gruning\Gsyscall\Gwaition。处于这些状态的Groutine即被看做是活跃的或者说正在被调度。
    • 注意：垃圾回收所在Groutine的状态也处于这个范围内的话，也会被纳入该计数器。

  • GOOS：目标操作系统

  • runtime.GC：会让运行时系统进行一次强制性的垃圾收集

    1. 强制的垃圾回收：不管怎样，都要进行的垃圾回收。
    2. 非强制的垃圾回收：只会在一定条件下进行的垃圾回收（即运行时，系统自上次垃圾回收之后新申请的堆内存的单元（也成为单元增量）达到指定的数值）。

  • GOROOT：获取goroot目录

  • GOOS : 查看目标操作系统 很多时候，我们会根据平台的不同实现不同的操作，就而已用GOOS了：

runtime.Gosched()

  • 让出CPU时间片，重新等待安排任务
  • 大概意思就是本来计划的好好的周末出去烧烤，但是你妈让你去相亲,两种情况第一就是你相亲速度非常快，见面就黄不耽误你继续烧烤，第二种情况就是你相亲速度特别慢，见面就是你侬我侬的，耽误了烧烤，但是还馋就是耽误了烧烤你还得去烧烤
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package main

import (
    "fmt"
    "runtime"
)

func main() {
    go func(s string) {
        for i := 0; i < 2; i++ {
            fmt.Println(s)
        }
    }("world")
    // 主协程
    for i := 0; i < 2; i++ {
        // 让出时间片，先让别的协程执行，它执行完，再回来执行此协程
        runtime.Gosched()
        fmt.Println("hello")
    }
}

runtime.Goexit()

退出当前协程(一边烧烤一边相亲，突然发现相亲对象太丑影响烧烤，果断让她滚蛋，然后也就没有然后了)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package main

import (
    "fmt"
    "runtime"
)

func main() {
    go func() {
        defer fmt.Println("A.defer")
        func() {
            defer fmt.Println("B.defer")
            // 结束协程
            runtime.Goexit()
            defer fmt.Println("C.defer")
            fmt.Println("B")
        }()
        fmt.Println("A")
    }()
  
    for {}
}

runtime.GOMAXPROCS()

  • Go运行时的调度器使用GOMAXPROCS参数来确定需要使用多少个OS线程来同时执行Go代码。默认值是机器上的CPU核心数。
  • 例如在一个8核心的机器上，调度器会把Go代码同时调度到8个OS线程上（GOMAXPROCS是m:n调度中的n）。
  • Go语言中可以通过runtime.GOMAXPROCS()函数设置当前程序并发时占用的CPU逻辑核心数。
  • Go1.5版本之前，默认使用的是单核心执行。Go1.5版本之后，默认使用全部的CPU逻辑核心数。
  • 我们可以通过将任务分配到不同的CPU逻辑核心上实现并行的效果，这里举个例子：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
func a() {
    for i := 1; i < 10; i++ {
        fmt.Println("A:", i)
    }
}

func b() {
    for i := 1; i < 10; i++ {
        fmt.Println("B:", i)
    }
}

func main() {
    runtime.GOMAXPROCS(1)
    go a()
    go b()
    time.Sleep(time.Second)
}

两个任务只有一个逻辑核心，此时是做完一个任务再做另一个任务。 将逻辑核心数设为2，此时两个任务并行执行，代码如下。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
func a() {
    for i := 1; i < 10; i++ {
        fmt.Println("A:", i)
    }
}

func b() {
    for i := 1; i < 10; i++ {
        fmt.Println("B:", i)
    }
}

func main() {
    runtime.GOMAXPROCS(2)
    go a()
    go b()
    time.Sleep(time.Second)
}

Go语言中的操作系统线程和goroutine的关系：

  • 一个操作系统线程对应用户态多个goroutine。
  • go程序可以同时使用多个操作系统线程。
  • goroutine和OS线程是多对多的关系，即m:n。