10.md

runtime包

[[toc]]

[toc]

runtime.Gosched()

让出CPU时间片，重新等待安排任务

大概意思就是本来计划的好好的周末出去烧烤，但是你妈让你去相亲，两种情况

第一就是你相亲速度非常快，见面就黄不耽误你继续烧烤，

第二种情况就是你相亲速度特别慢，见面就是你侬我侬的，耽误了烧烤，但是还馋就是耽误了烧烤你还得去烧烤

/*
 * @Description: runtime.Gosched()
 * @Author: xiongxinwei [email protected]
 * @Date: 2022-10-04 21:37:41
 * @LastEditTime: 2022-10-19 12:34:48
 * @FilePath: \undefinedd:\文档\最近的\awesome-golang\docs\code\go-super\10-main.go
 * @Github_Address: https://github.com/cubxxw/awesome-cs-cloudnative-blockchain
 * Copyright (c) 2022 by xiongxinwei [email protected], All Rights Reserved. @blog: http://nsddd.top
 */
package main

import (
    "fmt"
    "runtime"
)

func main() {
    go func(s string) {
        for i := 0; i < 2; i++ {
            fmt.Println(s)   //传入的s是world
        }
    }("world")
    // 主协程
    for i := 0; i < 2; i++ {
        // 切一下，再次分配任务
        runtime.Gosched()   //让出时间片
        fmt.Println("hello")
    }
}

🚀 编译结果如下：

D:\文档\最近的\awesome-golang\docs\code\go-super>go run 10-main.go
world
world
hello
hello

📜 对上面的解释：

相亲的速度太快了感觉不出来

package main

import (
	"fmt"
	"runtime"
)

func main() {
	go func(s string) {
		for i := 0; i < 50; i++ {
			fmt.Println(s)
		}
	}("world")
	// 主协程
	for i := 0; i < 50; i++ {
		// 切一下，再次分配任务
		runtime.Gosched()
		fmt.Println("hello")
	}
}

🚀 编译结果如下：

runtime.Goexit()

退出当前协程

一边烧烤一边相亲，突然发现相亲对象太丑影响烧烤，果断让她滚蛋，然后也就没有然后了

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 {
    }
}

🚀 编译结果如下：

[Running] go run "d:\文档\最近的\awesome-golang\docs\code\go-super\10-main.go"
B.defer
A.defer

📜 对上面的解释：

也就是说后面的代码都没有执行了。defer本身就是延迟执行语句，也就是 fmt.Println("C.defer")并没有执行，因为已经结束了。

当有多个 defer 行为被注册时，它们会以逆序执行（类似栈，即后进先出），下面的代码是将一系列的数值打印语句按顺序延迟处理，如下所示：

package main

import (
    "fmt"
)

func main() {

    fmt.Println("defer begin")

    // 将defer放入延迟调用栈
    defer fmt.Println(1)

    defer fmt.Println(2)

    // 最后一个放入, 位于栈顶, 最先调用
    defer fmt.Println(3)

    fmt.Println("defer end")
}

代码输出如下：

defer begin
defer end
3
2
1

结果分析如下：

• 代码的延迟顺序与最终的执行顺序是反向的。
• 延迟调用是在 defer 所在函数结束时进行，函数结束可以是正常返回时，也可以是发生宕机时。

之前for一直阻塞着，或许我们也可打开柱塞

💡简单的一个案例如下：

package main

import (
	"fmt"
	"runtime"
	"time"
)

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 {
        fmt.Println("main")
		defer fmt.Println("main defer")
		time.Sleep(5 * time.Second)
		break
	}
}

🚀 编译结果如下：

D:\文档\最近的\awesome-golang\docs\code\go-super>go run 10-main.go
main
B.defer
A.defer
main defer

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逻辑核心上实现并行的效果，这里举个例子：

package main

import (
	"fmt"
	"runtime"
	"time"
)

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，此时两个任务并行执行，代码如下。

package main

import (
	"fmt"
	"runtime"
	"time"
)

func a() {
	for i := 1; i < 10; i++ {
		fmt.Println("A:", i)
		//等待一秒
		time.Sleep(time.Second)
	}
}

func b() {
	for i := 1; i < 10; i++ {
		fmt.Println("B:", i)
		//等待一秒
		time.Sleep(time.Second)
	}
}

func main() {
	runtime.GOMAXPROCS(4)   //给4个，哥有的是cpu
	go a()
	go b()
	time.Sleep(time.Second * 10)
}

🚀 编译结果如下：

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

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

END 链接

• ⬆️上一节🔗⬇️下一节🔗

• Ⓜ️回到首页🏠

• 🫵参与贡献💞❤️‍🔥💖)

• ✴️版权声明 © :本书所有内容遵循CC-BY-SA 3.0协议（署名-相同方式共享）©