开发者

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

目录
  • golang查看CPU使用率与内存
    • 1 psutil
      • 1.1 概念与应用场景
      • 1.2 子包:CPU、disk、host、mem、net、process等
      • 1.3 实例
    • 2 golang获取指定进程的CPU利用率与内存
      • 2.1 代码
      • 2.2 效果
      • 2.3 其他
    • 拓展:源码里//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,"readBy编程tes":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 0xc000www.devze.com03e620 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使用率是没有平均之后的

    golang查看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)
    	}
    	coujavascriptnts, 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", c编程puPercent/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:

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

    mac:

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

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

    2.3 其他

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

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

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

    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. /qZrnZlQ/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使用率与内存的资料请关注编程客栈(www.devze.com)其它相关文章!

    0

    上一篇:

    下一篇:

    精彩评论

    暂无评论...
    验证码 换一张
    取 消

    最新开发

    开发排行榜