Go Runtime功能初探
Go Runtime功能初探
题图来自 Understand Compile Time && Runtime! Improving Golang Performance(1)[1]
以下内容,是对 运行时 runtime的神奇用法[2] 的学习与记录
目录:
- 1.获取GOROOT环境变量
- 2.获取GO的版本号
- 3.获取本机CPU个数
- 4.设置最大可同时执行的最大CPU数
- 5.设置cup profile 记录的速录
- 6.查看cup profile 下一次堆栈跟踪数据
- 7.立即执行一次垃圾回收
- 8.给变量绑定方法,当垃圾回收的时候进行监听
- 9.查看内存申请和分配统计信息
- 10.查看程序正在使用的字节数
- 11.查看程序正在使用的对象数
- 12.获取调用堆栈列表
- 13.获取内存profile记录历史
- 14.执行一个断点
- 15.获取程序调用go协程的栈踪迹历史
- 16.获取当前函数或者上层函数的标识号、文件名、调用方法在当前文件中的行号
- 17.获取与当前堆栈记录相关链的调用栈踪迹
- 18.获取一个标识调用栈标识符pc对应的调用栈
- 19.获取调用栈所调用的函数的名字
- 20.获取调用栈所调用的函数的所在的源文件名和行号
- 21.获取该调用栈的调用栈标识符
- 22.获取当前进程执行的cgo调用次数
- 23.获取当前存在的go协程数
- 24.终止掉当前的go协程
- 25.让其他go协程优先执行,等其他协程执行完后,在执行当前的协程
- 26.获取活跃的go协程的堆栈profile以及记录个数
- 27.将调用的go协程绑定到当前所在的操作系统线程,其它go协程不能进入该线程
- 28.解除go协程与操作系统线程的绑定关系
- 29.获取线程创建profile中的记录个数
- 30.控制阻塞profile记录go协程阻塞事件的采样率
- 31.返回当前阻塞profile中的记录个数
1. GOROOT()获取GOROOT环境变量
GOROOT() 返回Go的根目录。如果存在GOROOT环境变量,返回该变量的值;否则,返回创建Go时的根目录
package main
import (
"fmt"
"runtime"
)
func main() {
fmt.Println(runtime.GOROOT()) // /Users/fliter/.g/go
}
2. Version() 获取GO的版本号
Version() 返回Go的版本字符串。要么是提交的hash和创建时的日期;要么是发行标签如"go1.20"
package main
import (
"fmt"
"runtime"
)
func main() {
fmt.Println(runtime.Version()) // go1.19
}
3. NumCPU() 获取本机CPU个数
NumCPU返回本地机器的逻辑CPU个数
package main
import (
"fmt"
"runtime"
)
func main() {
fmt.Println(runtime.NumCPU()) // 8
}
4. GOMAXPROCS() 设置最大可同时执行的最大CPU数
GOMAXPROCS() 设置可同时执行的最大CPU数,并返回先前的设置。 若 n < 1,则不会更改当前设置。
本地机器的逻辑CPU数可通过 NumCPU 查询。该函数在调度程序优化后会去掉?(啥时候..)
package main
import (
"fmt"
"runtime"
"time"
)
func main() {
runtime.GOMAXPROCS(1)
startTime := time.Now()
var s1 chan int64 = make(chan int64)
var s2 chan int64 = make(chan int64)
var s3 chan int64 = make(chan int64)
var s4 chan int64 = make(chan int64)
go calc(s1)
go calc(s2)
go calc(s3)
go calc(s4)
<-s1
<-s2
<-s3
<-s4
endTime := time.Now()
fmt.Println(endTime.Sub(startTime)) // 第一行注释掉 耗时: 386.954625ms; 取消注释 耗时: 1.34715s
}
func calc(s chan int64) {
var count int64 = 0
for i := 0; i < 1000000000; i++ {
count += int64(i)
}
s <- count
}
5. SetCPUProfileRate() 设置cup profile 记录的速录
SetCPUProfileRate() 设置CPU profile记录的速率为平均每秒hz次。如果hz<=0,SetCPUProfileRate会关闭profile的记录。如果记录器在执行,该速率必须在关闭之后才能修改
绝大多数使用者应使用runtime/pprof包或testing包的-test.cpuprofile
选项而非直接使用SetCPUProfileRate
6. CPUProfile 查看cup profile 下一次堆栈跟踪数据
func CPUProfile() []byte
已废弃
7. GC() 立即执行一次垃圾回收
Go三种触发GC的方式之一 (另外两种为2分钟固定一次 && 达到阈值时触发)
package main
import (
"runtime"
"time"
)
type Student struct {
name string
}
func main() {
var i *Student = new(Student)
runtime.SetFinalizer(i, func(i interface{}) {
println("垃圾回收了") // 垃圾回收了
})
runtime.GC() // 如果将这行注释,则上面不会输出
time.Sleep(time.Second)
}
8. SetFinalizer() 给变量绑定方法,当垃圾回收的时候进行监听
func SetFinalizer(x, f interface{})
注意x必须是指针类型,f 函数的参数一定要和x保持一致,或者写interface{},不然程序会报错
代码同上例
9. ReadMemStats() 查看内存申请和分配统计信息
可以获得如下信息:
type MemStats struct {
// 一般统计
Alloc uint64 // 已申请且仍在使用的字节数
TotalAlloc uint64 // 已申请的总字节数(已释放的部分也算在内)
Sys uint64 // 从系统中获取的字节数(下面XxxSys之和)
Lookups uint64 // 指针查找的次数
Mallocs uint64 // 申请内存的次数
Frees uint64 // 释放内存的次数
// 主分配堆统计
HeapAlloc uint64 // 已申请且仍在使用的字节数
HeapSys uint64 // 从系统中获取的字节数
HeapIdle uint64 // 闲置span中的字节数
HeapInuse uint64 // 非闲置span中的字节数
HeapReleased uint64 // 释放到系统的字节数
HeapObjects uint64 // 已分配对象的总个数
// L低层次、大小固定的结构体分配器统计,Inuse为正在使用的字节数,Sys为从系统获取的字节数
StackInuse uint64 // 引导程序的堆栈
StackSys uint64
MSpanInuse uint64 // mspan结构体
MSpanSys uint64
MCacheInuse uint64 // mcache结构体
MCacheSys uint64
BuckHashSys uint64 // profile桶散列表
GCSys uint64 // GC元数据
OtherSys uint64 // 其他系统申请
// 垃圾收集器统计
NextGC uint64 // 会在HeapAlloc字段到达该值(字节数)时运行下次GC
LastGC uint64 // 上次运行的绝对时间(纳秒)
PauseTotalNs uint64
PauseNs [256]uint64 // 近期GC暂停时间的循环缓冲,最近一次在[(NumGC+255)%256]
NumGC uint32
EnableGC bool
DebugGC bool
// 每次申请的字节数的统计,61是C代码中的尺寸分级数
BySize [61]struct {
Size uint32
Mallocs uint64
Frees uint64
}
}
package main
import (
"fmt"
"runtime"
"time"
)
type Student2 struct {
name string
}
func main() {
var list = make([]*Student2, 0)
for i := 0; i < 100000; i++ {
var s *Student2 = new(Student2)
list = append(list, s)
}
memStatus := runtime.MemStats{}
runtime.ReadMemStats(&memStatus)
fmt.Printf("申请的内存:%d\n", memStatus.Mallocs) // 申请的内存:100250
fmt.Printf("释放的内存次数:%d\n", memStatus.Frees) // 释放的内存次数:45
time.Sleep(time.Second)
}
10. InUseBytes() 查看程序正在使用的字节数
func (r *MemProfileRecord) InUseBytes() int64
InUseBytes 返回正在使用的字节数(AllocBytes – FreeBytes)
11. InUseObjects() 查看程序正在使用的对象数
func (r *MemProfileRecord) InUseObjects() int64
InUseObjects 返回正在使用的对象数(AllocObjects - FreeObjects)
12. Stack() 获取调用堆栈列表
func (r *MemProfileRecord) Stack() []uintptr
Stack返回关联至此记录的调用栈踪迹,即r.Stack0的前缀
13. MemProfile() 获取内存profile记录历史
func MemProfile(p []MemProfileRecord, inuseZero bool) (n int, ok bool)
MemProfile 返回当前内存profile中的记录数n
-
若len(p)>=n,MemProfile会将此分析报告复制到p中并返回(n, true);
-
若len(p)<n,MemProfile则不会更改p,而只返回(n, false)
如果inuseZero为true,该profile就会包含无效分配记录(其中r.AllocBytes>0,而r.AllocBytes==r.FreeBytes。这些内存都是被申请后又释放回运行时环境的)
大多数调用者应当使用runtime/pprof包或testing包的-test.memprofile
标记,而非直接调用MemProfile
14. Breakpoint() 执行一个断点
runtime.Breakpoint()
15. Stack() 获取程序调用go协程的栈踪迹历史
func Stack(buf []byte, all bool) int
Stack 将调用其的go程的调用栈踪迹格式化后写入到buf中并返回写入的字节数
若all为true,函数会在写入当前go程的踪迹信息后,将其它所有go程的调用栈踪迹都格式化写入到buf中
package main
import (
"fmt"
"runtime"
"time"
)
func main() {
go showRecord()
time.Sleep(time.Second)
buf := make([]byte, 10000000000)
runtime.Stack(buf, true)
fmt.Println(string(buf))
}
func showRecord() {
ticker := time.Tick(time.Second)
for t := range ticker {
fmt.Println(t)
}
}
输出:
2023-04-19 17:25:26.386522 +0800 CST m=+1.001105543
2023-04-19 17:25:27.386892 +0800 CST m=+2.001489376
2023-04-19 17:25:28.386505 +0800 CST m=+3.001116043
2023-04-19 17:25:29.38553 +0800 CST m=+4.000154334
2023-04-19 17:25:30.385618 +0800 CST m=+5.000255584
2023-04-19 17:25:31.385817 +0800 CST m=+6.000468334
2023-04-19 17:25:32.385528 +0800 CST m=+7.000192918
2023-04-19 17:25:33.385646 +0800 CST m=+8.000323543
goroutine 1 [running]:
main.main()
/Users/fliter/runtime-demo/15Stack.go:13 +0x68
goroutine 4 [chan receive]:
main.showRecord()
/Users/fliter/runtime-demo/15Stack.go:19 +0xac
created by main.main
/Users/fliter/runtime-demo/15Stack.go:10 +0x24
16. Caller() 获取当前函数或者上层函数的标识号、文件名、调用方法在当前文件中的行号
func Caller(skip int) (pc uintptr, file string, line int, ok bool)
package main
import (
"fmt"
"runtime"
)
func main() {
pc, file, line, ok := runtime.Caller(0)
fmt.Println(pc) // 4336410771
fmt.Println(file) // /Users/fliter/runtime-demo/16Caller.go
fmt.Println(line) //9
fmt.Println(ok) //true
}
pc = 4336410771 不是main函数的标识,而是runtime.Caller 方法的标识,line = 13 标识它在main方法中的第13行被调用
//package main
//
//import (
// "fmt"
// "runtime"
//)
//
//func main() {
// pc, file, line, ok := runtime.Caller(0)
// fmt.Println(pc) // 4336410771
// fmt.Println(file) // /Users/fliter/runtime-demo/16Caller.go
// fmt.Println(line) //9
// fmt.Println(ok) //true
//}
package main
import (
"fmt"
"runtime"
)
func main() {
pc, _, line, _ := runtime.Caller(1)
fmt.Printf("main函数的pc:%d\n", pc) // main函数的pc:4364609931
fmt.Printf("main函数被调用的行数:%d\n", line) // main函数被调用的行数:250
show()
}
func show() {
pc, _, line, _ := runtime.Caller(1)
fmt.Printf("show函数的pc:%d\n", pc) // show函数的pc:4364974271
fmt.Printf("show函数被调用的行数:%d\n", line) // show函数被调用的行数:27
// 这个是main函数的栈
pc, _, line, _ = runtime.Caller(2)
fmt.Printf("show的上层函数的pc:%d\n", pc) // show的上层函数的pc:4364609931
fmt.Printf("show的上层函数被调用的行数:%d\n", line) // show的上层函数被调用的行数:250
pc, _, _, _ = runtime.Caller(3)
fmt.Println(pc) //4364778899
pc, _, _, _ = runtime.Caller(4)
fmt.Println(pc) // 0
}
golang获取调用者的方法名及所在行数[3]
runtime.Caller的性能问题[4]
17. Callers() 获取与当前堆栈记录相关链的调用栈踪迹
func Callers(skip int, pc []uintptr) int
会把当前go程调用栈上的调用栈标识符填入切片pc中,返回写入到pc中的项数。实参skip为开始在pc中记录之前所要跳过的栈帧数,0表示Callers自身的调用栈,1表示Callers所在的调用栈。返回写入p的项数
package main
import (
"fmt"
"runtime"
)
func main() {
pcs := make([]uintptr, 10)
i := runtime.Callers(1, pcs)
fmt.Println(pcs[:i]) // [4311883569 4311525404 4311694372]
}
获得了三个pc 其中有一个是main方法自身的
18. FuncForPC() 获取一个标识调用栈标识符pc对应的调用栈
func FuncForPC(pc uintptr) *Func
package main
import (
"runtime"
)
func main() {
pcs := make([]uintptr, 10)
i := runtime.Callers(1, pcs)
for _, pc := range pcs[:i] {
println(runtime.FuncForPC(pc))
}
}
输出:
0x102f660f0
0x102f5c9f0
0x102f64840
用途见下
19. Name() 获取调用栈所调用的函数的名字
func (f *Func) string
package main
import (
"runtime"
)
func main() {
pcs := make([]uintptr, 10)
i := runtime.Callers(1, pcs)
for _, pc := range pcs[:i] {
funcPC := runtime.FuncForPC(pc)
println(funcPC.Name())
}
}
输出:
main.main
runtime.main
runtime.goexit
20. FileLine() 获取调用栈所调用的函数的所在的源文件名和行号
func (f *Func) FileLine(pc uintptr) (file string, line int)
package main
import (
"runtime"
)
func main() {
pcs := make([]uintptr, 10)
i := runtime.Callers(1, pcs)
for _, pc := range pcs[:i] {
funcPC := runtime.FuncForPC(pc)
file, line := funcPC.FileLine(pc)
println(funcPC.Name(), file, line)
}
}
输出:
main.main /Users/fliter/runtime-demo/20FileLine.go 9
runtime.main /Users/fliter/.g/go/src/runtime/proc.go 259
runtime.goexit /Users/fliter/.g/go/src/runtime/asm_arm64.s 1166
21. Entry() 获取该调用栈的调用栈标识符
func (f *Func) Entry() uintptr
package main
import (
"runtime"
)
func main() {
pcs := make([]uintptr, 10)
i := runtime.Callers(1, pcs)
for _, pc := range pcs[:i] {
funcPC := runtime.FuncForPC(pc)
println(funcPC.Entry())
}
}
输出:
4310699120
4310540672
4310690704
22. NumCgoCall() 获取当前进程执行的cgo调用次数
获取当前进程调用C方法的次数
func NumCgoCall() int64
package main
import (
"runtime"
)
/*
#include <stdio.h>
*/
import "C"
func main() {
println(runtime.NumCgoCall()) // 1
}
没有调用C的方法为什么是1呢?因为 import C 会调用C包中的init方法
package main
import (
"runtime"
)
/*
#include <stdio.h>
// 自定义一个c语言的方法
static void myPrint(const char* msg) {
printf("myPrint: %s", msg);
}
*/
import "C"
func main() {
// 调用c方法
C.myPrint(C.CString("Hello,C\n")) // myPrint: Hello,C
println(runtime.NumCgoCall()) // 3
}
23. NumGoroutine() 获取当前存在的go协程数
func NumGoroutine() int
package main
import "runtime"
func main() {
go print()
print()
println(runtime.NumGoroutine()) // 2
}
func print() {
}
当前程序有 2个go协程 一个是main.go主协程, 另外一个是 go print()
24. Goexit() 终止掉当前的go协程
func Goexit()
package main
import (
"fmt"
"runtime"
)
func main() {
print()
fmt.Println("继续执行")
}
func print() {
fmt.Println("准备结束go协程")
runtime.Goexit()
defer fmt.Println("结束了")
}
输出:
准备结束go协程
fatal error: no goroutines (main called runtime.Goexit) - deadlock!
exit status 2
Goexit终止调用它的go协程,其他协程不受影响,Goexit会在终止该go协程前执行所有的defer函数,前提是defer必须在它前面定义,如下
package main
import (
"fmt"
"runtime"
)
func main() {
print()
fmt.Println("继续执行")
}
func print() {
fmt.Println("准备结束go协程")
defer fmt.Println("结束了--会输出出来")
runtime.Goexit()
//defer fmt.Println("结束了")
}
输出:
准备结束go协程
结束了--会输出出来
fatal error: no goroutines (main called runtime.Goexit) - deadlock!
exit status 2
如果在 main主协程调用该方法,会终止 主协程,但不会让main返回,因为main函数没有返回,
程序会继续执行其他go协程,当其他go协程执行完毕后,程序就会崩溃
package main
import (
"fmt"
"runtime"
"time"
)
func main() {
start := time.Now()
go func() {
time.Sleep(3e9)
println("123")
}()
defer fmt.Println(time.Since(start))
runtime.Goexit()
}
输出:
20.5µs
123
fatal error: no goroutines (main called runtime.Goexit) - deadlock!
exit status 2
25. Gosched() 让其他go协程优先执行,等其他协程执行完后,再执行当前的协程
func Gosched()
package main
import (
"fmt"
)
func main() {
go print25()
fmt.Println("继续执行")
}
func print25() {
fmt.Println("执行打印方法")
}
调用了go print方法,但是还未执行, main函数就执行完毕了(启一个协程也是需要时间的,这个时间比for循环,比程序继续执行要耗时多很多)
可以使用channel,waitgroup等,此处使用 runtime.Gosched()
package main
import (
"fmt"
"runtime"
)
func main() {
go print25()
runtime.Gosched()
fmt.Println("继续执行")
}
func print25() {
fmt.Println("执行打印方法")
}
输出:
执行打印方法
继续执行
[Rust vs Go:常用语法对比(13)-将优先权让给其他线程](https://json.dashen.tech/2021/09/14/Rust-vs-Go-%E5%B8%B8%E7%94%A8%E8%AF%AD%E6%B3%95%E5%AF%B9%E6%AF%94-13/ "Rust vs Go:常用语法对比(13 "Rust vs Go:常用语法对比(13)-将优先权让给其他线程")-将优先权让给其他线程")
Go用两个协程交替打印100以内的奇偶数[5]
26. GoroutineProfile() 获取活跃的go协程的堆栈profile以及记录个数
func GoroutineProfile(p []StackRecord) (n int, ok bool)
// GoroutineProfile returns n, the number of records in the active goroutine stack profile.
// If len(p) >= n, GoroutineProfile copies the profile into p and returns n, true.
// If len(p) < n, GoroutineProfile does not change p and returns n, false.
//
// Most clients should use the runtime/pprof package instead
// of calling GoroutineProfile directly.
func GoroutineProfile(p []StackRecord) (n int, ok bool) {
return goroutineProfileWithLabels(p, nil)
}
package main
import (
"fmt"
"runtime"
)
func main() {
for i := 0; i < 10; i++ {
go func(k int) {
fmt.Println(i)
}(i)
}
fmt.Println("----------------")
p := make([]runtime.StackRecord, 10000)
fmt.Println(runtime.GoroutineProfile(p)) // 1 true
}
输出:
10
10
10
10
10
10
10
----------------
7
10
10
1 true
pprof里面使用了此func
Go 应用的性能优化[6]
27. LockOSThread() 将调用的go协程绑定到当前所在的操作系统线程,其它go协程不能进入该线程
func LockOSThread()
将调用的go程绑定到它当前所在的操作系统线程。除非调用的go程退出或调用UnlockOSThread,否则它将总是在该线程中执行,而其它go程不能进入该线程
package main
import (
"fmt"
"runtime"
"time"
)
func main() {
go calcSum1()
go calcSum2()
time.Sleep(time.Second * 10)
}
func calcSum1() {
runtime.LockOSThread()
start := time.Now()
count := 0
for i := 0; i < 10000000000; i++ {
count += i
}
end := time.Now()
fmt.Println("calcSum1耗时")
fmt.Println(end.Sub(start))
defer runtime.UnlockOSThread()
}
func calcSum2() {
start := time.Now()
count := 0
for i := 0; i < 10000000000; i++ {
count += i
}
end := time.Now()
fmt.Println("calcSum2耗时")
fmt.Println(end.Sub(start))
}
输出:
calcSum1耗时
3.295679583s
calcSum2耗时
3.296763125s
看起来没有太大的差别;
但估计在很多个协程(涉及到频繁的调度和切换),但是有一项重要功能需独占一个核,可使用该func
Go LockOSThread[7]
28. UnlockOSThread() 解除go协程与操作系统线程的绑定关系
func UnlockOSThread()
将调用此func的协程,解除和其绑定的操作系统线程
若调用的协程未调用LockOSThread,UnlockOSThread不做操作
从1,10之后,调用了多少次LockOSThread,就要使用UnlockOSThread接触绑定..
29. ThreadCreateProfile() 获取线程创建profile中的记录个数
func ThreadCreateProfile(p []StackRecord) (n int, ok bool)
返回线程创建profile中的记录个数。
如果len(p)>=n,本func就会将profile中的记录复制到p中并返回(n, true)
若len(p)<n,则不会更改p,而只返回(n, false)
绝大多数情况下应当使用runtime/pprof包,而非直接调用ThreadCreateProfile
30. SetBlockProfileRate() 控制阻塞profile记录go协程阻塞事件的采样率
func SetBlockProfileRate(rate int)
SetBlockProfileRate 控制阻塞profile记录go程阻塞事件的采样频率。对于一个阻塞事件,平均每阻塞rate纳秒,阻塞profile记录器就采集一份样本。
要在profile中包括每一个阻塞事件,需传入rate=1
要完全关闭阻塞profile的记录,需传入rate<=0
31. BlockProfile() 返回当前阻塞profile中的记录个数
func BlockProfile(p []BlockProfileRecord) (n int, ok bool)
BlockProfile返回当前阻塞profile中的记录个数
-
如果len(p)>=n,本函数就会将此profile中的记录复制到p中并返回(n, true)
-
如果len(p)<n,本函数则不会修改p,而只返回(n, false)
绝大多数情况应当使用runtime/pprof包或testing包的-test.blockprofile
标记, 而非直接调用 BlockProfile
参考资料
[1]Understand Compile Time && Runtime! Improving Golang Performance(1): https://levelup.gitconnected.com/improving-golang-performance-1-must-master-two-key-concepts-238a2055c926
[2]运行时 runtime的神奇用法: https://blog.csdn.net/u011525168/article/details/88401166
[3]golang获取调用者的方法名及所在行数: https://dashen.tech/2018/05/18/golang%E8%8E%B7%E5%8F%96%E8%B0%83%E7%94%A8%E8%80%85%E7%9A%84%E6%96%B9%E6%B3%95%E5%90%8D%E5%8F%8A%E6%89%80%E5%9C%A8%E8%A1%8C%E6%95%B0/
[4]runtime.Caller的性能问题: https://dashen.tech/2019/11/11/runtime-Caller%E7%9A%84%E6%80%A7%E8%83%BD%E9%97%AE%E9%A2%98/
[5]Go用两个协程交替打印100以内的奇偶数: https://dashen.tech/2022/04/03/Go%E7%94%A8%E4%B8%A4%E4%B8%AA%E5%8D%8F%E7%A8%8B%E4%BA%A4%E6%9B%BF%E6%89%93%E5%8D%B0100%E4%BB%A5%E5%86%85%E7%9A%84%E5%A5%87%E5%81%B6%E6%95%B0/
[6]Go 应用的性能优化: https://zhuanlan.zhihu.com/p/406826295
[7]Go LockOSThread: https://dashen.tech/2017/07/11/Go-LockOSThread/