golang查看CPU使用率与内存的方法详解

 更新时间:2023年10月22日 10:09:31   作者:NPE~  
这篇文章主要给大家介绍了golang查看CPU使用率与内存的方法,以及拓展介绍源码里//go:指令,文中有详细的代码示例以及图文介绍,需要的朋友可以参考下

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

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

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

以上就是golang查看CPU使用率与内存的方法详解的详细内容,更多关于golang CPU使用率与内存的资料请关注脚本之家其它相关文章!

相关文章

  • golang 一次性定时器Timer用法及实现原理详解

    golang 一次性定时器Timer用法及实现原理详解

    这篇文章主要为大家介绍了golang 一次性定时器Timer用法及实现原理详解,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步,早日升职加薪
    2022-08-08
  • Go语言中JWT的创建和解析操作详解

    Go语言中JWT的创建和解析操作详解

    JWT的全名是Json web token,是为了在网络应用环境间传递声明而执行的一种基于JSON的开放标准,这篇文章主要介绍了在Go语言中JWT的创建和解析操作,感兴趣的同学可以参考下文
    2023-05-05
  • Golang判断两个链表是否相交的方法详解

    Golang判断两个链表是否相交的方法详解

    这篇文章主要为大家详细介绍了如何通过Golang判断两个链表是否相交,文中的示例代码讲解详细,感兴趣的小伙伴可以跟随小编一起学习一下
    2023-03-03
  • go语言定时器Timer及Ticker的功能使用示例详解

    go语言定时器Timer及Ticker的功能使用示例详解

    这篇文章主要为大家介绍了go语言定时器的功能使用示例详解,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步早日升职加薪
    2022-04-04
  • GoFrame错误处理常用方法及错误码使用示例

    GoFrame错误处理常用方法及错误码使用示例

    这篇文章主要为大家介绍了GoFrame错误处理常用方法及错误码使用示例详解,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步,早日升职加薪
    2022-06-06
  • Go语言常见哈希函数的使用

    Go语言常见哈希函数的使用

    哈希表(Hash table,也叫散列表),是根据关键码值(Key value)而直接进行访问的数据结构。也就是说,它通过把关键码值映射到表中一个位置来访问记录,以加快查找的速度。具体的介绍网上有很详细的描述,如闲聊哈希表 ,这里就不再累述了;
    2015-03-03
  • Go语言接口的嵌套的具体使用

    Go语言接口的嵌套的具体使用

    在Go语言中,不仅结构体与结构体之间可以嵌套,接口与接口间也可以通过嵌套创造出新的接口,本文主要介绍了Go语言接口的嵌套的具体使用,感兴趣的可以了解一下
    2023-04-04
  • golang 实现时间戳和时间的转化

    golang 实现时间戳和时间的转化

    这篇文章主要介绍了golang 实现时间戳和时间的转化操作,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
    2021-05-05
  • golang elasticsearch Client的使用详解

    golang elasticsearch Client的使用详解

    这篇文章主要介绍了golang elasticsearch Client的使用详解,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
    2021-05-05
  • 详解Go如何优雅的对时间进行格式化

    详解Go如何优雅的对时间进行格式化

    这篇文章主要为大家详细介绍了Go语言中是如何优雅的对时间进行格式化的,文中的示例代码讲解详细,感兴趣的小伙伴可以跟随小编一起了解一下
    2023-06-06

最新评论