精华内容
下载资源
问答
  • top命令是Linux下常用的性能分析工具,能够实时显示系统中各个进程的资源占用状况,类似于Windows的任务管理器。但是这样虽然看的东西多,但是闲的比较乱,并且从如此多的内容中找到我们所需要的也较为困难,故此...

    top命令是Linux下常用的性能分析工具,能够实时显示系统中各个进程的资源占用状况,类似于Windows的任务管理器

    可以直接使用top命令查看整体情况,如图:



    但是这样虽然看的东西多,但是闲的比较乱,并且从如此多的内容中找到我们所需要的也较为困难,故此可以增加一些参数来优化显示结果,使之更清晰。

    例如,通过ps命令我们找到所要跟踪的进程的名字和ID



    在确认进程信息之后我们就可以使用top命令来进程跟踪了。这里我们要学习下top命令的参数(此处为简述,有兴趣的同学可以找专门的材料进行学习)

    -b:以批处理模式操作;
    -c:显示完整的治命令;
    -d:屏幕刷新间隔时间;
    -I:忽略失效过程;
    -s:保密模式;
    -S:累积模式;
    -i<时间>:设置间隔时间;
    -u<用户名>:指定用户名;
    -p<进程号>:指定进程;
    -n<次数>:循环显示的次数。

    以上就是可选参数,可以根据自己的需求进行组合。我们本次要使用的参数为d和p,使用d设置一个刷新时间,使用p来确定要看那些进程。


    命令结果如下:



    现在看到的结果就比较清晰了。


    同学们学会了么。


    欢迎交流。

    展开全文
  • PHP CUP 内存 使用率 这一类关键字出来的文章一大把,但大都是在Linux环境下,windows下只有提出靠cmd语句实现的观点,但少有实际直接可行的代码,辗转试了一遍 wmic , systeminfo 各种并不熟稔的cmd命令,...
  • 常用的查看CPU使用率命令为top命令。 top命令是Linux下常用的性能分析工具,能够实时显示系统中各个进程的资源占用状况,类似于Windows的任务管理器。 top:Time of Process查看系统当前运行的情况,CPU、内存、...

    一、查看CPU使用率

    1、top命令
    在linux的系统维护中,可能需要经常查看cpu使用率,分析系统整体的运行情况。常用的查看CPU使用率命令为top命令。

    top命令是Linux下常用的性能分析工具,能够实时显示系统中各个进程的资源占用状况,类似于Windows的任务管理器。

    top:Time of Process查看系统当前运行的情况,CPU、内存、运行时间、交换分区、执行的线程等信息。通过top命令可以有效的发现系统的缺陷出在哪里,是内存不够、CPU处理能力不够、IO读写过高。

    top命令很常用,在第三行有显示CPU当前的使用情况。

     

    1.png

    如上所示,top命令可以看到总体的系统运行状态和cpu的使用率 。

    %us:表示用户空间程序的cpu使用率(没有通过nice调度)

    %sy:表示系统空间的cpu使用率,主要是内核程序。

    %ni:表示用户空间且通过nice调度过的程序的cpu使用率。

    %id:空闲cpu

    %wa:cpu运行时在等待io的时间

    %hi:cpu处理硬中断的数量

    %si:cpu处理软中断的数量

    %st:被虚拟机偷走的cpu

    注:96.9id,表示空闲CPU,即CPU未使用率,100%-96.9%=3.1%,即系统的cpu使用率为3.1%。

    2、其他命令可参考

    二、查看内存使用率

    1、top命令

     

    2.png

    (1)查看第四行KiB Mem
    (2)内存使用率=used/ total
    2、free命令
    可参考--正确计算Linux系统内存使用率

    三、查看磁盘使用率

    1、输入df命令

     

    3.png

     

    2、磁盘使用率=(Used列数据之和)/(1k-blocks列数据之和)

     

     

     

    四、查看磁盘大小

    df -hl

    注意事项:磁盘和内存的区别与联系:

    磁盘--也叫硬盘--或是U盘--或是移动硬盘
    1、硬盘与内存都是存储器,一个是内部,一个是外部。
    2、硬盘与内存的区别是很大的,这里只谈最主要的三点:1)内存是计算机的工作场所,硬盘用来存放暂时不用的信息;2)内存是半导体材料制作,硬盘是磁性材料制作;3)内存中的信息会随掉电而丢失,硬盘中的信息可以长久保存。
    3、内存与硬盘的联系也非常密切:这里只提一点:硬盘上的信息永远是暂时不用的,要用吗?请装入内存!CPU与硬盘不发生直接的数据交换,CPU只是通过控制信号指挥硬盘工作,硬盘上的信息只有在装入内存后才能被处理。
    4、计算机的启动过程就是一个从硬盘上把最常用信息装入内存的过程。
    5、硬盘则决定你的电脑可以装下多少东西,内存则决定你的电脑开机后一次最多可以运行多少程序(如手机运行内存)。

     

    展开全文
  • //内存使用率 char bufPreCPU[5]; MEMORYSTATUSEX statex; statex.dwLength = sizeof(statex); GlobalMemoryStatusEx(&statex); sprintf(bufPreCPU, "%ld%%\n", statex.dwMemoryLoad); puts(bufPreCPU)...
    #include <stdio.h>  
    #include <Windows.h>  
    #include<time.h>  
    #include <tchar.h>  
      
    #define DIV 1024  
    #define WIDTH 7  
    #define GB(x) (((x).HighPart << 2) + ((DWORD)(x).LowPart) / 1024.0 / 1024.0 / 1024.0)  
      
    #pragma warning(disable: 4996)     
      
    #define true 1  
    typedef unsigned char U_CHAR;  
      
    //获取系统时间  
    int getSystemTime(char* buffer){  
      
        char buf[128];  
        time_t rawtime;  
        struct tm * timeinfo;  
        time(&rawtime);  
        timeinfo = localtime(&rawtime);  
        strftime(buf, sizeof(buf), "Now is %Y-%m-%d %H:%M:%S", timeinfo);  
        strcpy(buffer,buf);  
    }  
      
    //CPU利用率  
    FILETIME m_preidleTime;  
    FILETIME m_prekernelTime;  
    FILETIME m_preuserTime;  
      
    __int64 CompareFileTime2(FILETIME time1, FILETIME time2)  
    {  
        __int64 a = time1.dwHighDateTime << 32 | time1.dwLowDateTime;  
        __int64 b = time2.dwHighDateTime << 32 | time2.dwLowDateTime;  
      
      
        return   b - a;  
    }  
      
    void GetCpuUseage()  
    {  
        GetSystemTimes(&m_preidleTime, &m_prekernelTime, &m_preuserTime);  
        Sleep(1000);  
    }  
      
    double CpuUseage()  
    {  
        FILETIME idleTime;  
        FILETIME kernelTime;  
        FILETIME userTime;  
        GetSystemTimes(&idleTime, &kernelTime, &userTime);  
      
      
        int idle = CompareFileTime2(m_preidleTime, idleTime);  
        int kernel = CompareFileTime2(m_prekernelTime, kernelTime);  
        int user = CompareFileTime2(m_preuserTime, userTime);  
      
      
        if (kernel + user == 0)  
            return 0.0;  
        //(总的时间-空闲时间)/总的时间=占用cpu的时间就是使用率  
        double cpu = abs((kernel + user - idle) * 100 / (kernel + user));  
      
        m_preidleTime = idleTime;  
        m_prekernelTime = kernelTime;  
        m_preuserTime = userTime;  
        return cpu;  
    }  
      
    //读取操作系统的名称  
    void GetSystemName(char* osname)  
    {  
        char buf[128];  
        SYSTEM_INFO info;        //用SYSTEM_INFO结构判断64位AMD处理器   
        GetSystemInfo(&info);    //调用GetSystemInfo函数填充结构   
        OSVERSIONINFOEX os;  
        os.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);  
      
        strcpy(buf, "unknown OperatingSystem.");  
      
        if (GetVersionEx((OSVERSIONINFO *)&os))  
        {  
            //下面根据版本信息判断操作系统名称   
            switch (os.dwMajorVersion)//判断主版本号  
            {  
            case 4:  
                switch (os.dwMinorVersion)//判断次版本号   
                {  
                case 0:  
                    if (os.dwPlatformId == VER_PLATFORM_WIN32_NT)  
                        strcpy(buf, "Microsoft Windows NT 4.0"); //1996年7月发布   
                    else if (os.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS)  
                        strcpy(buf, "Microsoft Windows 95");  
                    break;  
                case 10:  
                    strcpy(buf, "Microsoft Windows 98");   
                    break;  
                case 90:  
                    strcpy(buf, "Microsoft Windows Me");   
                    break;  
                }  
                break;  
      
            case 5:  
                switch (os.dwMinorVersion)  //再比较dwMinorVersion的值  
                {  
                case 0:  
                    strcpy(buf, "Microsoft Windows 2000"); //1999年12月发布  
                    break;  
      
                case 1:  
                    strcpy(buf, "Microsoft Windows XP"); //2001年8月发布  
                    break;  
      
                case 2:  
                    if (os.wProductType == VER_NT_WORKSTATION  
                        && info.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64)  
                    {  
                        strcpy(buf, "Microsoft Windows XP Professional x64 Edition");   
                    }  
                    else if (GetSystemMetrics(SM_SERVERR2) == 0)  
                        strcpy(buf, "Microsoft Windows Server 2003"); //2003年3月发布   
                    else if (GetSystemMetrics(SM_SERVERR2) != 0)  
                        strcpy(buf, "Microsoft Windows Server 2003 R2");   
                    break;  
                }  
                break;  
      
            case 6:  
                switch (os.dwMinorVersion)  
                {  
                case 0:  
                    if (os.wProductType == VER_NT_WORKSTATION)  
                        strcpy(buf, "Microsoft Windows Vista");   
                    else  
                        strcpy(buf, "Microsoft Windows Server 2008"); //服务器版本   
                    break;  
                case 1:  
                    if (os.wProductType == VER_NT_WORKSTATION)  
                        strcpy(buf, "Microsoft Windows 7");   
                    else  
                        strcpy(buf, "Microsoft Windows Server 2008 R2");   
                    break;  
                }  
                break;  
            }  
        }//if(GetVersionEx((OSVERSIONINFO *)&os))  
      
        strcpy(osname, buf);  
    }  
      
    int main(){  
      
        //获取系统时间  
        char buffer[128];  
        getSystemTime(buffer);  
        puts(buffer);  
      
        //系统运行时间  
        clock_t start, finish;  
        double duration;  
      
        start = clock();  
        while (true)  
        {  
            finish = clock();  
            duration = (double)(finish - start) / CLOCKS_PER_SEC;  
            Sleep(1000);  
            printf("%.0f 秒\n", duration);  
      
        }  
      
        //系统版本名称  
        char osname[20];  
        GetSystemName(osname);  
        printf("%s\n", osname);  
      
        //CPU利用率  
        while (true)  
        {  
            U_CHAR  sysStateCpu[5];  
            double cpu = CpuUseage();  
            sprintf((char*)sysStateCpu, "%.2lf", cpu);  
            printf("CPU使用率:%s%%\n", sysStateCpu);  
            Sleep(1000);  
        }  
      
        //内存使用率  
        char bufPreCPU[5];  
        MEMORYSTATUSEX statex;  
        statex.dwLength = sizeof(statex);  
        GlobalMemoryStatusEx(&statex);  
        sprintf(bufPreCPU, "%ld%%\n", statex.dwMemoryLoad);  
        puts(bufPreCPU);  
      
        //硬盘使用率 调用windows API  
        ULARGE_INTEGER FreeBytesAvailableC, TotalNumberOfBytesC, TotalNumberOfFreeBytesC;  
        ULARGE_INTEGER FreeBytesAvailableD, TotalNumberOfBytesD, TotalNumberOfFreeBytesD;  
        ULARGE_INTEGER FreeBytesAvailableE, TotalNumberOfBytesE, TotalNumberOfFreeBytesE;  
        ULARGE_INTEGER FreeBytesAvailableF, TotalNumberOfBytesF, TotalNumberOfFreeBytesF;  
               
        GetDiskFreeSpaceEx(_T("C:"), &FreeBytesAvailableC, &TotalNumberOfBytesC, &TotalNumberOfFreeBytesC);  
        GetDiskFreeSpaceEx(_T("D:"), &FreeBytesAvailableD, &TotalNumberOfBytesD, &TotalNumberOfFreeBytesD);  
        GetDiskFreeSpaceEx(_T("E:"), &FreeBytesAvailableE, &TotalNumberOfBytesE, &TotalNumberOfFreeBytesE);  
        GetDiskFreeSpaceEx(_T("F:"), &FreeBytesAvailableF, &TotalNumberOfBytesF, &TotalNumberOfFreeBytesF);  
        /*参数 类型及说明 
        lpRootPathName String,不包括卷名的磁盘根路径名 
        lpFreeBytesAvailableToCaller LARGE_INTEGER,指定一个变量,用于容纳调用者可用的字节数量 
        lpTotalNumberOfBytes LARGE_INTEGER,指定一个变量,用于容纳磁盘上的总字节数 
        lpTotalNumberOfFreeBytes LARGE_INTEGER,指定一个变量,用于容纳磁盘上可用的字节数 
        适用平台 
        Windows 95 OSR2,Windows NT 4.0*/  
        float totalHardDisk = GB(TotalNumberOfBytesC) + GB(TotalNumberOfBytesD) + GB(TotalNumberOfBytesE) + GB(TotalNumberOfBytesF);  
        float freeHardDisk = GB(TotalNumberOfFreeBytesC) + GB(TotalNumberOfFreeBytesD) + GB(TotalNumberOfFreeBytesE) + GB(TotalNumberOfFreeBytesF);  
          
        float hardDiskUsage = 1- freeHardDisk / totalHardDisk;  
      
        //CPU风扇转速  
      
        printf("hello world!\n");  
        system("pause");  
      
    }  

    转自:http://blog.csdn.net/davebobo/article/details/51698496

    展开全文
  •  psutil是一个跨平台库(http://code.google.com/p/psutil/),能够轻松实现获取系统运行的进程和系统利用(包括CPU、内存、磁盘、网络等)信息。它主要应用于系统监控,分析和限制系统资源及进程的管理。它实现...

    方法一:

            psutil是一个跨平台库(http://code.google.com/p/psutil/),能够轻松实现获取系统运行的进程和系统利用率(包括CPU、内存、磁盘、网络等)信息。它主要应用于系统监控,分析和限制系统资源及进程的管理。它实现了同等命令行工具提供的功能,如ps、top、lsof、netstat、ifconfig、who、df、kill、free、nice、ionice、iostat、iotop、uptime、pidof、tty、taskset、pmap等。目前支持32位和64位的Linux、Windows、OS X、FreeBSD和Sun Solaris等操作系统(参考https://www.cnblogs.com/liu-yao/p/5678157.html)

    root@h36:~# python
    Python 2.7.9 (default, Jun 29 2016, 13:08:31) 
    [GCC 4.9.2] on linux2
    Type "help", "copyright", "credits" or "license" for more information.
    >>> import psutil
    >>> psutil.virtual_memory().percent	#内存的占用率
    54.9
    >>> psutil.disk_partitions(all=False)	#磁盘分区信息
    [sdiskpart(device='/dev/sda1', mountpoint='/', fstype='ext4', opts='rw,relatime,errors=remount-ro,data=ordered'), sdiskpart(device='/dev/sda7', mountpoint='/tmp', fstype='ext4', opts='rw,relatime,data=ordered'), sdiskpart(device='/dev/sda8', mountpoint='/home', fstype='ext4', opts='rw,relatime,data=ordered'), sdiskpart(device='/dev/sda5', mountpoint='/var', fstype='ext4', opts='rw,relatime,data=ordered')]
    >>> psutil.disk_usage("/").percent	#磁盘sda1在"/"目录下的使用率
    30.7
    >>> psutil.cpu_percent(0)	#本机cpu的总占用率
    0.6
    >>> psutil.cpu_percent(percpu=True) #每个CPU每核的使用率,我这里的虚拟机是双CPU双核
    [0.1, 0.2, 0.0, 0.0]
    >>> psutil.sensors_temperatures()
    {'coretemp': [shwtemp(label='Physical id 0', current=100.0, high=100.0, critical=100.0), shwtemp(label='Core 0', current=100.0, high=100.0, critical=100.0), shwtemp(label='Core 1', current=100.0, high=100.0, critical=100.0), shwtemp(label='Physical id 1', current=100.0, high=100.0, critical=100.0), shwtemp(label='Core 0', current=100.0, high=100.0, critical=100.0), shwtemp(label='Core 1', current=100.0, high=100.0, critical=100.0)]}

    疑惑:在命令行中执行以上命令CPU使用率都正常,可是写入py脚本(print(psutil.cpu_percent(0)))文件后执行却不是0.0就是100.0,奇了怪了

    解决:虽然在命令行中psutil.cpu_percent(0)能出正常结果,但是上面那个疑惑在脚本里还必须不能使用0,比如写成psutil.cpu_percent(1)才能解决上面的问题,这个参数是时间间隔多少秒获取CPU使用率。

    注:在使用psutil模块时要注意版本大小,一开始我在Debian8.6下用apt-get install pustil直接装后咋也获取不了CPU温度,虽然按官方网站https://pypi.python.org/pypi/psutil#downloads在命令行下执行psutil.sensors_temperatures()却报错,后来我才意识到了有可能是版本过低的问题,于是去下载了较新的psutil 5.4.2才解决了问题(也可以不去官网下载psutil 5.4.2tar包,应该用pip安装,它就会去自动下载最新了psutil版本了,挺省事的倒是。先执行apt-get install python-pip安装pip,用pip install psutil之前可能还需要重要的一步apt-get install python-dev,否则会报错:

    psutil/_psutil_common.c:9:20: fatal error: Python.h: No such file or directory
    
     #include <Python.h>
    
                        ^


    补充(代码来自http://blog.51cto.com/dgd2010/1868851):Python获取网卡信息(名称、MAC、IP、网关等)

    Python pypi库中一个模块名字叫“netifaces”,使用C语言写的一个第三方模块。可以:
    1.获取本机的所有网关
    2.获取本机所有的接口Interface(网卡NIC)
    3.获取本机指定接口的详细信息,包括IP地址、子网掩码、广播地址、MAC地址等

    #!/usr/bin/python
    # encoding: utf-8
    # -*- coding: utf8 -*-
    """
    Created by PyCharm.
    File:               LinuxBashShellScriptForOps:getNetworkStatus.py
    User:               Guodong
    Create Date:        2016/11/2
    Create Time:        16:20
     
    show Windows or Linux network Nic status, such as MAC address, Gateway, IP address, etc
    """
    
    import os
    import sys
     
    try:
        import netifaces
    except ImportError:
        try:
            command_to_execute = "pip install netifaces || easy_install netifaces"
            os.system(command_to_execute)
        except OSError:
            print "Can NOT install netifaces, Aborted!"
            sys.exit(1)
        import netifaces
     
    routingGateway = netifaces.gateways()['default'][netifaces.AF_INET][0]
    routingNicName = netifaces.gateways()['default'][netifaces.AF_INET][1]
     
    for interface in netifaces.interfaces():
        if interface == routingNicName:
            # print netifaces.ifaddresses(interface)
            routingNicMacAddr = netifaces.ifaddresses(interface)[netifaces.AF_LINK][0]['addr']
            try:
                routingIPAddr = netifaces.ifaddresses(interface)[netifaces.AF_INET][0]['addr']
                # TODO(Guodong Ding) Note: On Windows, netmask maybe give a wrong result in 'netifaces' module.
                routingIPNetmask = netifaces.ifaddresses(interface)[netifaces.AF_INET][0]['netmask']
            except KeyError:
                pass
     
    display_format = '%-30s %-20s'
    print display_format % ("Routing Gateway:", routingGateway)
    print display_format % ("Routing NIC Name:", routingNicName)
    print display_format % ("Routing NIC MAC Address:", routingNicMacAddr)
    print display_format % ("Routing IP Address:", routingIPAddr)
    print display_format % ("Routing IP Netmask:", routingIPNetmask)
    
    运行结果:
    # python getNetworkStatus.py
    Routing Gateway:               10.6.28.254
    Routing NIC Name:              eth0
    Routing NIC MAC Address:       06:7f:12:00:00:15
    Routing IP Address:            10.6.28.28

    Routing IP Netmask:            255.255.255.0

    获取ip还有种写法:

    import socket
    import fcntl
    import struct
    
    def get_ip_address(ifname): 
        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) 
        print socket.inet_ntoa(fcntl.ioctl(s.fileno(), 0x8915, struct.pack('256s', ifname[:15]))[20:24]) 
    
    get_ip_address('lo')
    get_ip_address('eth0')

    运行结果:

    127.0.0.1
    10.6.28.28

    >>> import netifaces
    >>> netifaces.interfaces()
    [u'lo', u'eth0', u'eth1', u'eth2']
    >>> psutil.net_io_counters(pernic=True)
    {'lo': snetio(bytes_sent=141053, bytes_recv=141053, packets_sent=1411, packets_recv=1411, errin=0, errout=0, dropin=0, dropout=0), 'eth2': snetio(bytes_sent=74862, bytes_recv=16424, packets_sent=920, packets_recv=81, errin=0, errout=0, dropin=0, dropout=0), 'eth1': snetio(bytes_sent=126292, bytes_recv=34980, packets_sent=1515, packets_recv=174, errin=0, errout=0, dropin=0, dropout=0), 'eth0': snetio(bytes_sent=21560891, bytes_recv=1316735948, packets_sent=164194, packets_recv=1119225, errin=0, errout=0, dropin=0, dropout=0)}
    >>> print(netifaces.interfaces()[2])
    eth1
    >>> print(psutil.net_io_counters(pernic=True)["lo"][0])
    141053

    小综合:

    #!/usr/bin/env python
    # -*- coding: utf-8 -*-
    
    import json, os, time, psutil, netifaces
    
    def GetCPUorDiskTemper(type='Core'):
        dict_cpu_temp = {}
        if hasattr(psutil, "sensors_temperatures"):
            temps = psutil.sensors_temperatures()
        else:
            temps = {}
        cpu_each = []
        names = list(temps.keys())
        for name in names:
            if name in temps:
                for entry in temps[name]:
                    if type in entry.label:
                        dict_cpu_temp[entry.label] = entry.current
                        cpu_each.append(dict_cpu_temp[entry.label])
        cpu_top = sorted(dict_cpu_temp.items(),key=lambda d:d[0])[0][1]
        return {"cpu_top":cpu_top,"cpu_each":cpu_each}
    
    def GetCPUInfo():
        cpu_t = GetCPUorDiskTemper()["cpu_each"]
        cpu_num = int(os.popen("cat /proc/cpuinfo| grep 'physical id'| sort| uniq| wc -l").readline().strip())
        numb = os.popen("cat /proc/cpuinfo| grep 'cpu cores'| uniq").readline()
        cpucore_num = int(numb[12:-1])
        cpu_u = psutil.cpu_percent(percpu=True,interval=1)
        cpu = []
        cpu1 = {}
        list = {}
        y = 1
        z = 0
        data = []
        for i in range(0,len(cpu_u)):
            list = {"corename":"Core "+str(z),"cpu_u":cpu_u[i],"cpu_t":cpu_t[i]}
            z = z + 1
            data.append(list)
            if i+1 == cpucore_num*y:
                cpu1["data"] = data
                cpu1["cpuname"] = "cpu "+str(y-1)
                y = y + 1
                cpu.append(cpu1)
                cpu1 = {}
                data = []
                z = 0
        return cpu
    
    def GetNetwork():
        net = []
        for i in range(1,len(netifaces.interfaces())):
            netname = str(netifaces.interfaces()[i])
            bytes_sent = int(psutil.net_io_counters(pernic=True)[netname][0])
            bytes_recv = int(psutil.net_io_counters(pernic=True)[netname][1])
            eth_status = os.popen('sudo ethtool '+netname).readlines()[-1][16:-1]
            x = {"name":netname,"eth_status":eth_status,"bytes_sent":bytes_sent,"bytes_recv":bytes_recv}
            net.append(x)
        return net
        
    total = 0
    used = 0
    disk_partitions = psutil.disk_partitions(all=False)
    for i in range(0,len(disk_partitions)):
        partition = disk_partitions[i][1]
        total_each = psutil.disk_usage(partition)[0]
        total = total + total_each
        used_each = psutil.disk_usage(partition)[1]
        used = used + used_each
    disk_u = used/float(total)*100
    cpu_u = psutil.cpu_percent(1)
    cpu_t = GetCPUorDiskTemper()["cpu_top"]
    memory_u = psutil.virtual_memory().percent
    boot_time = psutil.boot_time()
    runtime = os.popen('cat /proc/uptime').readlines()[0].split(" ")[0]
    data = {"a":{"disku":disk_u,"memu":memory_u,"cpuu":cpu_u,"cput":cpu_t,"boot_time":boot_time,\
            "runtime":runtime},"b":GetNetwork(),"c":GetCPUInfo()}
    print(data)

    运行结果:

    {'a': {'cput': 100.0, 'cpuu': 0.2, 'disku': 29.98913391327393, 'memu': 40.5, 'boot_time': 1514893852.0, 'runtime': '89424.57'}, 'c': [{'cpuname': 'cpu 0', 'data': [{'corename': 'Core 0', 'cpu_t': 100.0, 'cpu_u': 1.0}, {'corename': 'Core 1', 'cpu_t': 100.0, 'cpu_u': 0.0}]}, {'cpuname': 'cpu 1', 'data': [{'corename': 'Core 0', 'cpu_t': 100.0, 'cpu_u': 0.0}, {'corename': 'Core 1', 'cpu_t': 100.0, 'cpu_u': 0.0}]}], 'b': [{'eth_status': 'yes', 'bytes_sent': 404589707, 'name': 'eth0', 'bytes_recv': 200725324}, {'eth_status': 'yes', 'bytes_sent': 71170, 'name': 'eth1', 'bytes_recv': 50232}, {'eth_status': 'yes', 'bytes_sent': 80868, 'name': 'eth2', 'bytes_recv': 48402}]}


    方法二:(不建议使用,方法一完全就够用而且还好。而且算的结果还和方法一不一样,我感觉方法一更准确一些吧)

    直接上代码:hui.py

    #!/usr/bin/env python
    # -*- coding:utf-8 -*-
    
    import os, time, re, sensors
    
    last_worktime=0
    last_idletime=0
    
    sensors.init()
    
    def get_mem_usage_percent():
        try:
            f = open('/proc/meminfo', 'r')
            for line in f:
                if line.startswith('MemTotal:'):
                    mem_total = int(line.split()[1])
                elif line.startswith('MemFree:'):
                    mem_free = int(line.split()[1])
                elif line.startswith('Buffers:'):
                    mem_buffer = int(line.split()[1])
                elif line.startswith('Cached:'):
                    mem_cache = int(line.split()[1])
                elif line.startswith('SwapTotal:'):
                    vmem_total = int(line.split()[1])
                elif line.startswith('SwapFree:'):
                    vmem_free = int(line.split()[1])
                else:
                    continue
            f.close()
        except:
            return None
        physical_percent = usage_percent(mem_total - (mem_free + mem_buffer + mem_cache), mem_total)
        virtual_percent = 0
        if vmem_total > 0:
            virtual_percent = usage_percent((vmem_total - vmem_free), vmem_total)
        return physical_percent, virtual_percent
    
    def usage_percent(use, total):
        try:
            ret = (float(use) / total) * 100
        except ZeroDivisionError:
            raise Exception("ERROR - zero division error")
        return ret
    
    def disk_use():
        statvfs = os.statvfs('/')
        total_disk_space = statvfs.f_frsize * statvfs.f_blocks
        free_disk_space = statvfs.f_frsize * statvfs.f_bfree
        disk_usage = (total_disk_space - free_disk_space) * 100.0 / total_disk_space
    #    disk_tip = "硬盘空间使用率:"+str(disk_usage)+"%"
    #    print(disk_tip)
        return disk_usage
    
    def mem_use():
        mem_usage = get_mem_usage_percent()
        mem_usage = mem_usage[0]
    #    mem_tip = "物理内存使用率:"+str(mem_usage)+"%"
    #    print(mem_tip)
        return mem_usage
        
    def cpu_use():
        global last_worktime, last_idletime
        f=open("/proc/stat","r")
        line=""
        while not "cpu " in line: line=f.readline()
        f.close()
        spl=line.split(" ")
        worktime=int(spl[2])+int(spl[3])+int(spl[4])
        idletime=int(spl[5])
        dworktime=(worktime-last_worktime)
        didletime=(idletime-last_idletime)
        rate=float(dworktime)/(didletime+dworktime)
        cpu_t = rate*100
        last_worktime=worktime
        last_idletime=idletime
        if(last_worktime==0): return 0
    #    cpu_tip = "CPU使用率:"+str(cpu_t)+"%"
    #    print(cpu_tip)
        return cpu_t
    
    def cpu_temperature():
        for chip in sensors.ChipIterator("coretemp-*"):
            i = 0
            sum = 0
            for feature in sensors.FeatureIterator(chip):
                sfi = sensors.SubFeatureIterator(chip, feature)
                vals = [sensors.get_value(chip, sf.number) for sf in sfi]
                sum = sum + vals[0]
                i = i + 1
    #            cpu_tmp = "CPU温度:"+sum/i+"℃"
    #            print(cpu_tmp)
            return sum/i
    
    disk = disk_use()
    print(disk)
    print(type(disk))
    mem = mem_use()
    print(mem)
    print(type(mem))
    cpua = cpu_use()
    print(cpua)
    print(type(cpua))
    cpub = cpu_temperature()
    print(cpub)
    print(type(cpub))
    sensors.cleanup()
    
    注意:CPU使用率、内存使用率、硬盘使用率都还好说,但是CPU温度就比较麻烦一些了,得使用sensors来整,lm_sensors的软件可以帮助我们来监控主板、CPU的工作电压、风扇转速、温度等数据。这些数据我们通常在主板的BIOS也可以看到。当我们可以在机器运行的时候通过lm_sensors随时来监测着CPU的温度变化,可以预防呵保护因为CPU过热而会烧掉。如果你没有这个模块,使用apt-get install lm-sensors命令来安装即可(我这里使用的是Debian8.6 64位)。

    还得和上面的同一目录下再来这么一个文件(https://github.com/paroj/sensors.py/blob/master/sensors.py)

    运行代码:python hui.py
    32.1816127961
    <type 'float'>
    37.7943290638
    <type 'float'>
    0.251490181586
    <type 'float'>
    100.0
    <type 'float'>

    疑惑:网上还有一种计算CPU使用率的方法,那就是用top命令来获取
    def cpu_use():
        cpu_usage = str(os.popen("top -n1 | awk '/Cpu\(s\):/ {print $2}'").readline().strip())
        cpu_tip = "CPU使用率:"+cpu_usage+"%"
        print(cpu_tip)
    但是和我上面的代码结果却不一样,用/proc/stat文件(http://server.51cto.com/sCollege-188250.htm)来计算得到0.252413215089,而用top命令得到的却是0.1

    注:你可能会对这里的CPU温度是100而困惑,执行sensors命令
    root@h36:~# sensors
    coretemp-isa-0000
    Adapter: ISA adapter
    Physical id 0: +100.0°C  (high = +100.0°C, crit = +100.0°C)
    Core 0:        +100.0°C  (high = +100.0°C, crit = +100.0°C)
    为什么会都是100呢?这不科学啊!我这里用的是VMware虚拟机下装的Debian,后来问别人说是这个读不出虚拟机的CPU温度来,至于原因我也不明白,只能读出真实物理机的温度,我试了下的确如此。



    参考:

    http://www.rojtberg.net/836/introducing-sensors-py/

    https://www.cnblogs.com/xuaijun/p/7985147.html

    展开全文
  • Windows Server 2008 R2服务器内存使用率过高,但与任务管理器中进程占用内存和不一致 原文:Windows Server 2008 R2服务器内存使用率过高,但与任务管理器中进程占用内存和不一致 系统环境: Windows...
  • 1, 首先当然是用wget下载indicator-sysmonitor,终端执行命令: wget -chttps://launchpad.net/indicator-sysmonitor/trunk/4.0/+download/indicator- sysmonitor_0.4.3_all.deb 2,终端执行:sudo apt-get ...
  • 获取CPU使用率脚本(vbs),另存为cpu.vbs:On Error Resume Next Set objProc = GetObject("winmgmts:\\.\root\cimv2:win32_processor='cpu0'") ...获取内存使用率脚本(vbs)...
  • 早上医院反应,PACS系统业务特别慢,登上服务器看内存已经使用了31.8G(32G的内存),打开任务管理器看 占用最多的是sqlserver.exe 大约8G 其他进程最大的也就IIS的进程,都没超过1G,加起来肯定到不了31.8G ...
  • 正确计算linux系统内存使用率

    万次阅读 2018-08-12 09:03:14
    图中的例子很典型,就是:多数的...具体的机制我们无需知道,我们需要知道的是,linux的内存管理机制的思想包括(不敢说就是)内存利用最大化。内核会把剩余的内存申请为cached,而cached不属于free范畴。当...
  • RT,我现在想获取Windows系统下CPU、内存使用率,网上查找的都是执行这个命令 String procCmd = System.getenv("windir") + "\\system32\\wbem\\wmic.exe process get Caption,CommandLine," + ...
  • 在清理前内存使用情况 free -m -m是单位,也可以-g 用以下命令清理内存 echo 1 > /proc/sys/vm/drop_caches ...清理后内存使用情况再用以下命令看看。 free –m 多出很多内存了吧。 ...
  • Linux下内存使用率正确的算法

    万次阅读 2014-12-15 15:18:59
    Linux下各种内存的使用...linux 系统查看物理内存使用率命令,以百分比形式输出? 回答的答案是: free -m | sed -n '2p' | awk '{print "used mem is "$3"M,total mem is "$2"M,used percent is "$3/$2*100"%"}'
  • 如何正确计算LINUX内存使用率

    万次阅读 2012-07-10 14:20:00
    图中的例子不是很典型,典型的情况是:多数的linux系统在free命令后会发现free(剩余)的内存很少,而自己又没有开过多的程序或服务。 对于上述的情况,正确的解释是:linux的内存管理机制与windows的有所不同。...
  • jmap命令可以获得运行中的jvm的堆的快照,从而可以离线分析堆,以检查内存泄漏,检查一些严重影响性能的大对象的创建,检查系统中什么对象最多,各种对象所占内存的大小等等。可以使用jmap生成Heap Dump。  j...
  • 通过snmp的OID获取对方主机的内存利用率及CPU的使用率
  • linux系统内存实际使用率

    千次阅读 2014-07-02 20:18:25
    linux系统内存实际使用率 图中的例子很典型,就是:多数的linux系统在free命令后会发现free(剩余)的内存很少,而自己又没有开过多的程序或服务。 对于上述的情况,正确的解释是: linux的内存管理...
  • 通过jmx可以监控vm内存使用,系统内存使用等 ,特点是通过window和linux命令获得CPU使用率
  • 查看jvm内存使用命令

    万次阅读 2017-08-06 12:19:02
    jmap (linux下特有,也是很常用的一个命令) 观察运行中的jvm物理内存的占用情况。 参数如下: -heap :打印jvm heap的情况 -histo: 打印jvm heap的直方图。其输出信息包括类名,对象数量,对象占用...
  • windows下cmd使用wget命令

    万次阅读 2018-12-12 19:38:56
    那么windows平台下到底可否使用?答案是确定的可以的!!! 请从下面链接下载wget(1.11.4) for win: 。下载完成后,解压出wget.exe文件,把它放到c:\windows\sytem32目录下。加粗样式 进入命令行 运行—cmd----- ...
  • 一、查看CPU使用率 top命令 top:time of process,查看系统当前的运行情况,查看CPU、内存、运行时间、交换分区、执行的线程等信息。 top命令是linux下常用的性能分析工具,能够实时的显示系统中各个进程中资源...
  • strReturn = "内存总数: " & round(objOS.TotalVisibleMemorySize / 1024) & " MB" & vbCrLf &"内存可用数: " & round(objOS.FreePhysicalMemory / 1024) & " MB" & vbCrLf &"内存使用率 :" & Round(((objOS....
  • 监控Java应用程序Windows内存使用情况

    千次阅读 2008-08-22 11:12:00
    尽管 Java™运行时能够解决大量的内存管理问题,但对程序的内存占用情况保持警惕仍然是...作者将澄清关于内存使用的一些常见误解,介绍很多有用的工具,同时还将提供何时以及如何使用它们的指南。 Java技术最知名的一
  • 在linux系统中,一般使用系统自带的top和mpstat命令查看CPU的性能和使用情况,使用free和pmap命令查看系统的内存使用情况。这里就这几个命令的使用做详细的介绍。 top命令  在系统维护的过程中,随时可能有需要...
  • 为了测试某个服务的稳定性,通常需要在服务长时间运行的情况下,监控其资源消耗情况,比如cpu和内存使用 这里借助python的psutil这个包可以很方便的监控指定进程号(PID)的cpu和内存使用情况 代码 process_...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 63,988
精华内容 25,595
关键字:

windows内存使用率命令