golang查看CPU使用率与内存及源码中的//go:指令

最新推荐文章于 2023-10-23 10:14:56 发布

NPE~

最新推荐文章于 2023-10-23 10:14:56 发布

阅读量1.2k

点赞数 1

分类专栏： go 文章标签： golang 开发语言后端 CPU 监控实战

本文链接：https://blog.csdn.net/weixin_45565886/article/details/133822240

版权

go 专栏收录该内容

45 篇文章 8 订阅

订阅专栏

golang查看CPU使用率与内存

1 psutil

1.1 概念与应用场景

psutil是业内一个用于监控OS资源的软件包，目前已经多种语言，包括但不限于Python、Go。

gopsutil是 Python 工具库psutil 的 Golang 移植版，可以帮助我们方便地获取各种系统和硬件信息。gopsutil为我们屏蔽了各个系统之间的差异，具有非常强悍的可移植性。有了gopsutil，我们不再需要针对不同的系统使用syscall调用对应的系统方法。更棒的是gopsutil的实现中没有任何cgo的代码，使得交叉编译成为可能。

应用场景：go语言本身高并发，无环境依赖部署，轻量级，内存占用低等特点，加上gopsutil可以做性能监控，系统监控或系统信息采集，信息上报等

使用：

go get "github.com/shirou/gopsutil"

1.2 子包：CPU、disk、host、mem、net、process等

gopsutil将不同功能划分到不同的子包中，使用时直接引入子包，然后调用，子包分类如下:

CPU 相关；
disk 磁盘相关
host 主机相关
mem 内存相关
net 网络相关
process 进程相关
docke docker相关

①采集CPU

info方法包含cpu整个信息，Percent方法显示cpu使用率,而load值需要引入load包

//打印cpu相关信息
info, _ := cpu.Info()
for _, ci := range info {
   fmt.Println(ci)
}

//打印cpu使用率,每5秒一次，总共9次
for i := 1; i < 10; i++ {
   time.Sleep(time.Millisecond * 5000)
   percent, _ := cpu.Percent(time.Second, false)
   fmt.Printf("%v, cpu percent: %v", i, percent)
}

//显示cpu load值
avg, _ := load.Avg()
fmt.Println(avg)

②采集内存

VirtualMemory方法显示物理内存信息，SwapMemory方法显示交换内存信息

//显示物理内存信息
memory, _ := mem.VirtualMemory()
fmt.Printf("Total: %v, Free:%v,UsedPercent:%f%%\n",memory.Total, memory.Free, memory.UsedPercent)
//显示交换内存信息
swapMemory, _ := mem.SwapMemory()
fmt.Println(swapMemory)

import (
	"github.com/shirou/gopsutil/v3/mem"
)

func getMemInfo() {
	memInfo,err := mem.VirtualMemory()
	if err != nil {
		fmt.Println("get memory info fail. err： ", err)
	}
	// 获取总内存大小，单位GB
	memTotal := memInfo.Total/1024/1024/1024
	// 获取已用内存大小，单位MB
	memUsed := memInfo.Used/1024/1024
	// 可用内存大小
	memAva := memInfo.Available/1024/1024
	// 内存可用率
	memUsedPercent := memInfo.UsedPercent
	fmt.Printf("总内存: %v GB, 已用内存: %v MB, 可用内存: %v MB, 内存使用率: %.3f %% \n",memTotal,memUsed,memAva,memUsedPercent)
}

③采集主机信息

//显示机器启动时间戳
bootTime, _ := host.BootTime()
fmt.Println(bootTime)
//显示机器信息
info, _ := host.Info()
fmt.Println(info)
//显示终端用户
users, _ := host.Users()
for _,user := range users {
   fmt.Println(user.User)
}

④采集磁盘

Partitions方法显示所有分区信息，Usage方法显示分区使用量

//显示磁盘分区信息
partitions, _ := disk.Partitions(true)
for _,part := range partitions {
   fmt.Printf("part:%v\n",part.String())
   usage, _ := disk.Usage(part.Mountpoint)
   fmt.Printf("disk info:used :%v free:%v\n",usage.UsedPercent,usage.Free)
}

//显示磁盘分区IO信息
counters, _ := disk.IOCounters()
for k,v := range counters {
   fmt.Printf("%v,%v\n",k,v)
}

⑤采集进程信息

//显示所有进程名称和PID
processes, _ := process.Processes()
for _,process := range processes {
   fmt.Println(process.Pid)
   fmt.Println(process.Name())
}

⑥采集网络信息

//为了避免和内部包net冲突，改成net2
//显示显络信息和IO
counters, _ := net2.IOCounters(true)
for k,v := range  counters{
   fmt.Printf("%v:%v send:%v recv:%v\n", k, v, v.BytesSent, v.BytesRecv)
}

⑦采集docker信息

//显示dockerID列表
list, _ := docker.GetDockerIDList()
for _,v := range list{
   fmt.Println(v)
}

使用gopsutil工具包可以简单的就获取系统相关信息，对于信息采集，系统监控等场景非常方便就可以实现

对于复杂的进程管理，process子包功能调用也比较复杂，这里推荐另一个操作系统使用systemctl管理进程的包: github.com/coreos/go-systemd

参考文章：https://juejin.cn/post/6998709615269511181

1.3 实例

①获取cpu、内存、磁盘使用率

import github.com/shirou/gopsutil
 
func GetCpuPercent() float64 {
	percent, _:= cpu.Percent(time.Second, false)
	return percent[0]
}
 
func GetMemPercent()float64 {
	memInfo, _ := mem.VirtualMemory()
	return memInfo.UsedPercent
}
 
func GetDiskPercent() float64 {
	parts, _ := disk.Partitions(true)
	diskInfo, _ := disk.Usage(parts[0].Mountpoint)
	return diskInfo.UsedPercent
}
 
func main() {
	fmt.Println(GetCpuPercent())
	fmt.Println(GetMemPercent())
	fmt.Println(GetDiskPercent())
}

结果：

7.8125
71
43.12042706933934

②获取本机信息

info, _ := host.Info()
fmt.Println(info)

结果：

{"hostname":"WIN-SP09TQCP1U8","uptime":25308,"bootTime":1558574107,"procs":175,"os":"windows","platform":"Microsoft Windows 10 Pro","platformFamily":"Standalone Workstation","platformVersion":"10.0.17134 Build 17134","kernelVersion":"","virtualizationSystem":"","virtualizationRole":"","hostid":。。。}

③获取CPU信息

info, _ := cpu.Info() //总体信息
fmt.Println(info) 
//output：
[{"cpu":0,cores":4,"modelName":"Intel(R) Core(TM) i5-2520M CPU @ 2.50GHz","mhz":2501,。。。]
c, _ := cpu.Counts(true) //cpu逻辑数量
fmt.Println(c) //4
c, _ = cpu.Counts(false) //cpu物理核心
fmt.Println(c) //如果是2说明是双核超线程, 如果是4则是4核非超线程

用户CPU时间/系统CPU时间/空闲时间。。。等等

info, _ := cpu.Times(false)
fmt.Println(info)
//output：
[{"cpu":"cpu-total","user":1272.0,"system":1572.7,"idle":23092.3,"nice":0.0,"iowait":0.0,"irq":0.0,。。。}]
用户CPU时间：就是用户的进程获得了CPU资源以后，在用户态执行的时间。
系统CPU时间：用户进程获得了CPU资源以后，在内核态的执行时间。

CPU使用率，每秒刷新一次。

for{
    info, _ := cpu.Percent(time.Duration(time.Second), false)
    fmt.Println(info)
}

④获取内存（物理内存和交换区）信息

info, _ := mem.VirtualMemory()
fmt.Println(info)
info2, _ := mem.SwapMemory()
fmt.Println(info2)
//output：
{"total":8129818624,"available":4193423360,"used":3936395264,"usedPercent":48,"free":0,"active":0,"inactive":0,...}
{"total":8666689536,"used":4716843008,"free":3949846528,"usedPercent":0.5442496801583825,"sin":0,"sout":0,...}

总内存大小是8129818624 = 8 GB，已用3936395264 = 3.9 GB，使用了48%。而交换区大小是8666689536 = 8 GB。

⑤获取磁盘信息：分区、使用率、磁盘IO

info, _ := disk.Partitions(true) //所有分区
fmt.Println(info)
info2, _ := disk.Usage("E:") //指定某路径的硬盘使用情况
fmt.Println(info2)
info3, _ := disk.IOCounters() //所有硬盘的io信息
fmt.Println(info3)
//output：
[{"device":"C:","mountpoint":"C:","fstype":"NTFS","opts":"rw.compress"} {"device":"D:","mountpoint":"D:","fstype":"NTFS","opts":"rw.compress"} {"device":"E:","mountpoint":"E:","fstype":"NTFS","opts":"rw.compress"} ]
{"path":"E:","fstype":"","total":107380965376,"free":46790828032,"used":60590137344,"usedPercent":56.425398236866755,"inodesTotal":0,"inodesUsed":0,"inodesFree":0,"inodesUsedPercent":0}
map[C::{"readCount":0,"mergedReadCount":0,"writeCount":0,"mergedWriteCount":0,"readBytes":0,"writeBytes":4096,"readTime":0,"writeTime":0,"iopsInProgress":0,"ioTime":0,"weightedIO":0,"name":"C:","serialNumber":"","label":""} ...]

⑥获取网络信息

获取当前网络连接信息

info, _ := net.Connections("all") //可填入tcp、udp、tcp4、udp4等等
fmt.Println(info)
//output：
[{"fd":0,"family":2,"type":1,"localaddr":{"ip":"0.0.0.0","port":135},"remoteaddr":{"ip":"0.0.0.0","port":0},"status":"LISTEN","uids":null,"pid":668} {"fd":0,"family":2,"type":1,"localaddr":{"ip":"0.0.0.0","port":445},"remoteaddr":{"ip":"0.0.0.0","port":0},"status":"LISTEN","uids":null,"pid":4} {"fd":0,"family":2,"type":1,"localaddr":{"ip":"0.0.0.0","port":1801},"remoteaddr":{"ip":"0.0.0.0","port":0},"status":"LISTEN","uids":null,"pid":3860} 
...]

获取网络读写字节／包的个数

info, _ := net.IOCounters(false)
fmt.Println(info)
//output：[{"name":"all","bytesSent":6516450,"bytesRecv":36991210,"packetsSent":21767,"packetsRecv":33990,"errin":0,"errout":0,"dropin":0,"dropout":0,"fifoin":0,"fifoout":0}]

⑦获取进程信息

获取到所有进程信息

info, _ := process.Pids() //获取当前所有进程的pid
fmt.Println(info)
//output：
[0 4 96 464 636 740 748 816 852 880 976 348 564 668 912 1048 1120 1184 1268 1288。。。]
info2,_ := process.GetWin32Proc(1120) //对应pid的进程信息 
fmt.Println(info2)
//output：
[{svchost.exe 0xc00003e570 0xc00003e580 8 2019-05-23 09:15:28.444192 +0800 CST 5600 4 0xc00003e5b0 0 0 0 0 Win32_ComputerSystem WIN-SE89TTCP7U3 0xc00003e620 Win32_Process 0xc00003e650 0xc00005331e 209 6250000 0xc000053378 0xc0000533b8 Win32_OperatingSystem Microsoft Windows 10 专业版。。。}]
fmt.Println(info2[0].ParentProcessID) //获取父进程的pid

参考：https://blog.csdn.net/whatday/article/details/109620192

2 golang获取指定进程的CPU利用率与内存

2.1 代码

golang获取CPU利用率、内存与资源管理器保持一致

psutil返回的cpu percent是总的占用

mac上的活动监视器展示的cpu使用率是没有平均之后的
2. windows的资源管理器展示的是平均之后的，是占所有cpu核心的平均

package main

import (
	"fmt"
	"github.com/mitchellh/go-ps"
	"github.com/shirou/gopsutil/cpu"
	"github.com/shirou/gopsutil/process"
	"log"
	"runtime"
	"strings"
	"time"
)

var (
	s   []string
	pid int
)

func main() {
	processes, err2 := ps.Processes()
	if err2 != nil {
		log.Fatalf("%v", err2)
	}
	for _, p := range processes {
		//将___5go_build换为自己想要监控的进程名
		if strings.Contains(p.Executable(), "___5go_build") {
			fmt.Println(p.Executable())
			fmt.Println(p.Pid())
			pid = p.Pid()
		}
	}

	p, err := process.NewProcess(int32(pid))
	if err != nil {
		log.Fatal(err)
	}
	counts, err2 := cpu.Counts(true)
	if err2 != nil {
		log.Fatalf("%v\n", err2)
	}
	fmt.Println("counts=", counts)
	go func() {
		for {
			//cpuPercent, err := p.CPUPercent() //该方式不准确
			cpuPercent, err := p.Percent(time.Second * 3) //取样3s内的cpu使用， 返回的是总的cpu使用率;mac上不用除以cpuCounts
			if err != nil {
				log.Fatal(err)
			}

			memInfo, err := p.MemoryInfo()
			if err != nil {
				log.Fatal(err)
			}
			fmt.Printf("PID: %d\n", pid)
			switch runtime.GOOS {
			case "darwin":
				fmt.Printf("CPU占用: %.2f%%\n", cpuPercent)
			case "windows":
				fmt.Printf("CPU占用: %.2f%%\n", cpuPercent/float64(counts))

			}

			//source used := processMemory.RSS
			fmt.Printf("内存占用: %.2f MB\n", float64(memInfo.RSS)/1024/1024)
			//time.Sleep(time.Second * 1)
		}
	}()
	for {
		time.Sleep(time.Second * 5)
		fmt.Println("========== in process ==========")
	}

}

2.2 效果

win10：
在这里插入图片描述
mac：

2.3 其他

1 通过go原生runtime包获取进程占用内存

通过runtime.MemStats获取Sys字段来展示进程占用内存大小

package main

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

var (
    count = 100000000
    s     []string
)

func main() {
    for {
        if count > 0 {
            s = append(s, "431431242142142142")
            count--
            if count%5000000 == 0 {
                collectMem()
                fmt.Println("count=", count)
            }
        } else {
            collectMem()
        }

    }
}

func collectMem() {
    var stat runtime.MemStats
    runtime.ReadMemStats(&stat)
    fmt.Printf("alloc:%vMB totalAlloc:%vMB sys:%vMB NumGC:%v\n", stat.Alloc/1024/1024, stat.TotalAlloc/1024/1024, stat.Sys/1024/1024, stat.NumGC)
    //fmt.Println("pid=", os.Getpid())
    time.Sleep(time.Second * 5)
}


/*
    Alloc：已经分配但还未被释放的对象内存总量，单位为字节(heap)；
    TotalAlloc：运行时系统已经分配的内存总量，单位为字节；
    Sys：程序向操作系统申请的内存总量，单位为字节；
    NumGC：运行时系统执行的垃圾回收次数；
*/

2 通过差值计算

如果是有用到rclone同步数据，那么可以直接通过rclone获取到的API来做差值：Sys - HeapRealeased

拓展:源码里//go:指令

1. //go:linkname 符号别名

//go:linkname localname importpath.name

该指令指示编译器使用 importpath.name 作为源代码中声明为 localname 的变量或函数的目标文件符号名称。但是由于这个伪指令，可以破坏类型系统和包模块化，只有引用了 unsafe 包才可以使用。

简单来讲，就是 importpath.name 是 localname 的符号别名，编译器实际上会调用 localname。

使用的前提是使用了 unsafe 包才能使用。

案例：

import _ "unsafe" // for go:linkname

//go:linkname time_now time.now
func time_now() (sec int64, nsec int32, mono int64) {
 sec, nsec = walltime()
 return sec, nsec, nanotime() - startNano
}

2. //go:noescape 禁用逃逸分析

该指令指定下一个有声明但没有主体（意味着实现有可能不是 Go）的函数，不允许编译器对其做逃逸分析。

一般情况下，该指令用于内存分配优化。编译器默认会进行逃逸分析，会通过规则判定一个变量是分配到堆上还是栈上。

但凡事有意外，一些函数虽然逃逸分析其是存放到堆上。但是对于我们来说，它是特别的。我们就可以使用 go:noescape 指令强制要求编译器将其分配到函数栈上。

案例：

// memmove copies n bytes from "from" to "to".
// in memmove_*.s
//go:noescape
func memmove(to, from unsafe.Pointer, n uintptr)

我们观察一下这个案例，它满足了该指令的常见特性。如下：

memmove_*.s：只有声明，没有主体。其主体是由底层汇编实现的
memmove：函数功能，在栈上处理性能会更好

3. //go:nosplit 声明该堆栈跳出溢出检查

//go:nosplit
该指令指定文件中声明的下一个函数不得包含堆栈溢出检查。

简单来讲，就是这个函数跳过堆栈溢出的检查。

案例：

//go:nosplit
func key32(p *uintptr) *uint32 {
 return (*uint32)(unsafe.Pointer(p))
}

4. //go:nowritebarrierrec 处理读写屏障

//go:nowritebarrierrec

该指令表示编译器遇到写屏障时就会产生一个错误，并且允许递归。也就是这个函数调用的其他函数如果有写屏障也会报错。

简单来讲，就是针对写屏障的处理，防止其死循环。

案例：

//go:nowritebarrierrec
func gcFlushBgCredit(scanWork int64) {
    ...
}

5. //go:yeswritebarrierrec 与nowritebarrierrec相对

该指令与 go:nowritebarrierrec 相对，在标注 go:nowritebarrierrec 指令的函数上，遇到写屏障会产生错误。

而当编译器遇到 go:yeswritebarrierrec 指令时将会停止。

案例：

//go:yeswritebarrierrec
func gchelper() {
 ...
}

6. //go:noinline 禁止内联

//go:noinline
func unexportedPanicForTesting(b []byte, i int) byte {
 return b[i]
}

我们观察一下这个案例，是直接通过索引取值，逻辑比较简单。如果不加上 go:noinline 的话，就会出现编译器对其进行内联优化。

显然，内联有好有坏。该指令就是提供这一特殊处理。

7. //go:norace 禁止静态检测

该指令表示禁止进行竞态检测。

常见的形式就是在启动时执行 go run -race，能够检测应用程序中是否存在双向的数据竞争，非常有用。

//go:norace
func forkAndExecInChild(argv0 *byte, argv, envv []*byte, chroot, dir *byte, attr *ProcAttr, sys *SysProcAttr, pipe int) (pid int, err Errno) {
    ...
}

8. //go:notinheap：不允许从堆申请内存

该指令常用于类型声明，它表示这个类型不允许从 GC 堆上进行申请内存。

在运行时中常用其来做较低层次的内部结构，避免调度器和内存分配中的写屏障，能够提高性能。

案例：

// notInHeap is off-heap memory allocated by a lower-level allocator
// like sysAlloc or persistentAlloc.
//
// In general, it's better to use real types marked as go:notinheap,
// but this serves as a generic type for situations where that isn't
// possible (like in the allocators).
//
//go:notinheap
type notInHeap struct{}