1. runtime包

1.1.1. runtime.Gosched()

让出CPU时间片，重新等待安排任务(大概意思就是本来计划的好好的周末出去烧烤，但是你妈让你去相亲,两种情况第一就是你相亲速度非常快，见面就黄不耽误你继续烧烤，第二种情况就是你相亲速度特别慢，见面就是你侬我侬的，耽误了烧烤，但是还馋就是耽误了烧烤你还得去烧烤)

  1. package main
  3. import (
  4.     "fmt"
  5.     "runtime"
  6. )
  8. func main() {
  9.     go func(s string) {
  10.         for i := 0; i < 2; i++ {
  11.             fmt.Println(s)
  12.         }
  13.     }("world")
  14.     // 主协程
  15.     for i := 0; i < 2; i++ {
  16.         // 切一下，再次分配任务
  17.         runtime.Gosched()
  18.         fmt.Println("hello")
  19.     }
  20. }

1.1.2. runtime.Goexit()

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

  1. package main
  3. import (
  4.     "fmt"
  5.     "runtime"
  6. )
  8. func main() {
  9.     go func() {
  10.         defer fmt.Println("A.defer")
  11.         func() {
  12.             defer fmt.Println("B.defer")
  13.             // 结束协程
  14.             runtime.Goexit()
  15.             defer fmt.Println("C.defer")
  16.             fmt.Println("B")
  17.         }()
  18.         fmt.Println("A")
  19.     }()
  20.     for {
  21.     }
  22. }

1.1.3. 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. func a() {
  2.     for i := 1; i < 10; i++ {
  3.         fmt.Println("A:", i)
  4.     }
  5. }
  7. func b() {
  8.     for i := 1; i < 10; i++ {
  9.         fmt.Println("B:", i)
  10.     }
  11. }
  13. func main() {
  14.     runtime.GOMAXPROCS(1)
  15.     go a()
  16.     go b()
  17.     time.Sleep(time.Second)
  18. }

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

  1. func a() {
  2.     for i := 1; i < 10; i++ {
  3.         fmt.Println("A:", i)
  4.     }
  5. }
  7. func b() {
  8.     for i := 1; i < 10; i++ {
  9.         fmt.Println("B:", i)
  10.     }
  11. }
  13. func main() {
  14.     runtime.GOMAXPROCS(2)
  15.     go a()
  16.     go b()
  17.     time.Sleep(time.Second)
  18. }

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

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