C++获取windows和linux的cpu占用率

最新推荐文章于 2024-08-25 15:31:37 发布
最新推荐文章于 2024-08-25 15:31:37 发布
阅读量743 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_24022755/article/details/117335441
版权

c++

代码

cpuload.h

#pragma once

#include <iostream>
#include <vector>

#ifndef WIN32

class CPUData {
public:
  void ReadData(const std::string &line);

  std::size_t GetActiveTime() const;
  std::size_t GetIdleTime() const;
  std::size_t GetStateTime(unsigned int state) const;
  std::size_t GetTotalTime() const;

  const std::string &GetLabel() const;

public:
  static bool IsDataCPUStats(const std::string &line);

public:
  enum CPUStates {
    S_USER = 0,
    S_NICE,
    S_SYSTEM,
    S_IDLE,
    S_IOWAIT,
    S_IRQ,
    S_SOFTIRQ,
    S_STEAL,
    S_GUEST,
    S_GUEST_NICE,

    NUM_CPU_STATES
  };

private:
  static const std::string STR_CPU;
  static const std::string STR_TOT;

  static const std::size_t LEN_STR_CPU;

private:
  std::string mLabel;
  std::size_t mTimes[NUM_CPU_STATES];
};

inline std::size_t CPUData::GetActiveTime() const {
  return mTimes[S_USER] + mTimes[S_NICE] + mTimes[S_SYSTEM] + mTimes[S_IRQ] +
         mTimes[S_SOFTIRQ] + mTimes[S_STEAL] + mTimes[S_GUEST] +
         mTimes[S_GUEST_NICE];
}

inline std::size_t CPUData::GetIdleTime() const {
  return mTimes[S_IDLE] + mTimes[S_IOWAIT];
}

inline std::size_t CPUData::GetStateTime(unsigned int state) const {
  if (state < NUM_CPU_STATES)
    return mTimes[state];
  else
    return 0;
}

inline std::size_t CPUData::GetTotalTime() const {
  return mTimes[S_USER] + mTimes[S_NICE] + mTimes[S_SYSTEM] + mTimes[S_IDLE] +
         mTimes[S_IOWAIT] + mTimes[S_IRQ] + mTimes[S_SOFTIRQ] +
         mTimes[S_STEAL] + mTimes[S_GUEST] + mTimes[S_GUEST_NICE];
}

inline const std::string &CPUData::GetLabel() const { return mLabel; }

inline bool CPUData::IsDataCPUStats(const std::string &line) {
  return (!line.compare(0, LEN_STR_CPU, STR_CPU));
}

class CPUSnapshot {
public:
  CPUSnapshot();

  std::size_t GetNumEntries() const;

  const char *GetLabelTotal() const;
  const char *GetLabel(unsigned int cpu) const;

  std::size_t GetActiveTimeTotal() const;
  std::size_t GetActiveTime(unsigned int cpu) const;

  std::size_t GetIdleTimeTotal() const;
  std::size_t GetIdleTime(unsigned int cpu) const;

  std::size_t GetStateTimeTotal(unsigned int state) const;
  std::size_t GetStateTime(unsigned int state, unsigned int cpu) const;

  std::size_t GetTotalTimeTotal() const;
  std::size_t GetTotalTime(unsigned int cpu) const;

private:
  static const int INDEX_TOT;

private:
  std::vector<CPUData> mEntries;
};

inline std::size_t CPUSnapshot::GetNumEntries() const {
  return mEntries.size() - 1;
}

inline const char *CPUSnapshot::GetLabelTotal() const {
  return mEntries[INDEX_TOT].GetLabel().c_str();
}

inline const char *CPUSnapshot::GetLabel(unsigned int cpu) const {
  // skip total
  ++cpu;

  if (cpu < mEntries.size())
    return mEntries[cpu].GetLabel().c_str();
  else
    return NULL;
}

inline std::size_t CPUSnapshot::GetActiveTimeTotal() const {
  return mEntries[INDEX_TOT].GetActiveTime();
}

inline std::size_t CPUSnapshot::GetActiveTime(unsigned int cpu) const {
  // skip total
  ++cpu;

  if (cpu < mEntries.size())
    return mEntries[cpu].GetActiveTime();
  else
    return 0;
}

inline std::size_t CPUSnapshot::GetIdleTimeTotal() const {
  return mEntries[INDEX_TOT].GetIdleTime();
}

inline std::size_t CPUSnapshot::GetIdleTime(unsigned int cpu) const {
  // skip total
  ++cpu;

  if (cpu < mEntries.size())
    return mEntries[cpu].GetIdleTime();
  else
    return 0;
}

inline std::size_t CPUSnapshot::GetStateTimeTotal(unsigned int state) const {
  return mEntries[INDEX_TOT].GetStateTime(state);
}

inline std::size_t CPUSnapshot::GetStateTime(unsigned int state,
                                             unsigned int cpu) const {
  // skip total
  ++cpu;

  if (cpu < mEntries.size())
    return mEntries[cpu].GetStateTime(state);
  else
    return 0;
}

inline std::size_t CPUSnapshot::GetTotalTimeTotal() const {
  return mEntries[INDEX_TOT].GetTotalTime();
}

inline std::size_t CPUSnapshot::GetTotalTime(unsigned int cpu) const {
  // skip total
  ++cpu;

  if (cpu < mEntries.size())
    return mEntries[cpu].GetTotalTime();
  else
    return 0;
}
#endif

class LoadMnger {
public:
  ~LoadMnger();

  static LoadMnger *instance();

  double GetCpuUsage();

private:
  LoadMnger();
  static LoadMnger *m_instance;

#ifdef WIN32
  unsigned long long m_ullLastTime;
  unsigned long long m_ullLastIdleTime;
#else
  size_t m_ullLastTime;
  size_t m_ullLastIdleTime;
#endif
};

cpuload.cpp

#include "LoadManager.h"

#include <fstream>
#include <iostream>
#include <sstream>
#include <string>

#ifdef WIN32
#include <windows.h>
#else

using namespace std;

const std::string CPUData::STR_CPU("cpu");
const std::string CPUData::STR_TOT("tot");
const std::size_t CPUData::LEN_STR_CPU = 3;
const int CPUSnapshot::INDEX_TOT = 0;
#endif

LoadMnger *LoadMnger::m_instance = NULL;

LoadMnger::LoadMnger() {
	GetCpuUsage();
}

LoadMnger::~LoadMnger() {}

LoadMnger *LoadMnger::instance() {
  if (!m_instance)
    m_instance = new LoadMnger();
  return m_instance;
}

#ifdef WIN32
unsigned long long __FileTime2Utc(const FILETIME &ft) {
  LARGE_INTEGER li;
  li.LowPart = ft.dwLowDateTime;
  li.HighPart = ft.dwHighDateTime;
  return li.QuadPart;
}

double LoadMnger::GetCpuUsage() {
  FILETIME idleTime, kernelTime, userTime;
  if (!GetSystemTimes(&idleTime, &kernelTime, &userTime)) {
    printf("GetSystemTimes", GetLastError());
    return -1;
  }
  unsigned long long _time =
                         __FileTime2Utc(kernelTime) + __FileTime2Utc(userTime),
                     _idle_time = __FileTime2Utc(idleTime);
  if (!m_ullLastTime || !m_ullLastIdleTime) {
    m_ullLastIdleTime = _idle_time;
    m_ullLastTime = _time;
    return -1;
  }
  unsigned long long idle = _idle_time - m_ullLastIdleTime,
                     usage = _time - m_ullLastTime;
  m_ullLastIdleTime = _idle_time;
  m_ullLastTime = _time;
  if (!usage)
    return -1;
  return (usage - idle) * 100.0 / usage;
}
#else
double LoadMnger::GetCpuUsage() {
  CPUSnapshot Csp;

  size_t curacTime = Csp.GetActiveTimeTotal();
  size_t curidlTIme = Csp.GetIdleTimeTotal();
  const float ACTIVE_TIME = curacTime - m_ullLastTime;
  const float IDLE_TIME = curidlTIme - m_ullLastIdleTime;
  const float TOTAL_TIME = ACTIVE_TIME + IDLE_TIME;

  m_ullLastTime = curacTime;
  m_ullLastIdleTime = curidlTIme;
  return 100.f * ACTIVE_TIME / TOTAL_TIME;
}

// == PUBLIC FUNCTIONS ==
CPUSnapshot::CPUSnapshot() {
  std::ifstream fileStat("/proc/stat");

  std::string line;

  while (std::getline(fileStat, line)) {
    // cpu stats line found
    if (CPUData::IsDataCPUStats(line)) {
      // store entry
      mEntries.push_back(CPUData());
      CPUData &entry = mEntries.back();

      entry.ReadData(line);
    }
  }
}

// == PUBLIC FUNCTIONS ==

void CPUData::ReadData(const std::string &line) {
  std::istringstream ss(line);

  // read cpu label
  ss >> mLabel;

  // remove "cpu" from the label when it's a processor number
  if (mLabel.size() > LEN_STR_CPU)
    mLabel.erase(0, LEN_STR_CPU);
  // replace "cpu" with "tot" when it's total values
  else
    mLabel = STR_TOT;

  // read times
  for (int i = 0; i < NUM_CPU_STATES; ++i) {
    ss >> mTimes[i];
  }
}

#endif
main.cpp
#include "LoadManager.h"

#include <iostream>
#include <string>

#ifdef WIN32
#include <windows.h>
#else
#include <unistd.h>
#endif

using namespace std;

int main() {
  LoadMnger *mng = LoadMnger::instance();
  while (1) {
    //如果时间间隔太短会计算失败,具体可以看GetCpuUsage()中GetSystemTimes获取的结果
#ifdef WIN32
    Sleep(1000);
#else
    sleep(1);
#endif
    double usage = mng->GetCpuUsage();
    cout << "main:  " << usage << endl;
  }
  return 0;
}

代码是参考大佬的代码合并、修改而来，如有侵权，请私信删除。

部分源码来自：
https://github.com/vivaladav/cpu-stat
https://github.com/mewiteor/MonitorBar

Timorously.G
关注
C/+C++获取linux(Centos 7)系统下指定进程的CPU使用率和内存使用率等信息
温暖不了你的心的博客
04-20 974
目录前言代码 前言 linux系统一切皆文本，所以，系统相关信息可以通过读文件或执行shell命令的方式获取，这里采用后者的方式获取指定进程信息。 代码 .h文件 #include<iostream> #include<stdio.h> #include<string> #include<string.h> #include<stdlib.h> using namespace std; class ProcessInfo { public:
Linux —— Ubuntu下C++获取CPU使用率、GPU使用率、GPU温度
wx微信公众号“码农总动员”，获取更多编程知识
12-07 3014
Ubuntu下C++获取CPU使用率、GPU使用率、GPU温度
Windows下获得系统cpu空闲比及指定进程CPU占比
Joshua的专栏
02-29 402
【代码】Windows下获得系统cpu空闲比及指定进程CPU占比。
Linux编程： C++线程CPU使用率监控与分析工具
最新发布
Where there is life, there is hope.
08-25 1420
本文将介绍一个结合 C++ 和 Python 的高性能 CPU 使用率监控和分析工具。该工具通过读取 Linux 系统的 `/proc` 文件系统实时采集 CPU 使用数据，利用 UnQLite 数据库进行高效存储，并通过 Python 实现数据解析和可视化。本工具支持对多个进程同时进行分析。
Linux C++ 获取某一进程的CPU占用率以及内存占用情况
热门推荐
黑夜童话的博客
05-02 2万+
最近做监控相关东西的时候，需要获取某一进程CPU以及内存使用情况，就简单的写了一下，代码具体如下： #include #include #include #include #include #define VMRSS_LINE 17 #define VMSIZE_LINE 13 #define PROCESS_ITEM 14 typedef struct { unsigned l
C++编程中，利用WINDOWS API获得系统状态信息[CPU占用率，硬盘使用情况，内存使用情况]
编程爱好者
03-25 9242
#include #include #include #include #include #include #include #include #include #include #define SystemBasicInformation       0#define SystemPerformanceInformation 2#define SystemTimeInformation     
C++读取Linux设备运行状态信息(二) 读取CPU负载
休息一下接着来的博客
07-28 1254
1.cpu负载和cpu占用率的区别 这两个从一定程度上都可以反映一台机器的繁忙程度. cpu使用率反映的是当前cpu的繁忙程度，忽高忽低的原因在于占用cpu处理时间的进程可能处于io等待状态但却还未释放进入wait。 平均负载（load average）是指某段时间内占用cpu时间的进程和等待cpu时间的进程数，这里等待cpu时间的进程是指等待被唤醒的进程，不包括处于wait状态进程。 2. CPU负载 CPU的负载可以从文件**/proc/loadavg**中读取。 使用cat查看/proc/
c++ 计算cpu占用率
weixin_30905133的博客
01-24 884
计算CPU占用率就是获取系统总的内核时间 用户时间及空闲时间 其中空闲时间就是内核空转 所以内核时间包含空闲时间 然后计算 运行时间 = 内核时间 加 用户时间 减去 空闲时间 间隔时间 = 内核时间 加 用户时间 cpu使用率% =运行时间 /间隔时间 ; 无论单个进程cpu占用率还是系统整个cpu占用路 都是如此原理 核心代码就是如下几段 BOOL res = Get...
C++获取特定进程CPU使用率的实现代码
08-26
要获取进程的 CPU 使用率，我们需要使用 Windows API 中的 GetProcessTimes 函数，该函数可以获取进程的执行时间和系统时间。我们可以通过计算这两个时间的差值来获取进程的 CPU 使用率。 二、C++ 实现代码 我们将...
QT/C++实时获取CPU和内存的使用率
12-17
QT/C++实时获取CPU和内存使用率是软件开发中一项重要的功能，特别是在系统监控或性能分析的应用场景下。QT框架提供了跨平台的能力，使得我们可以在Windows、macOS、Linux等不同操作系统上编写代码，而C++作为其底层...
c++获取cpu使用率（包含系统和单进程）
09-02
这些代码可以帮助我们更好地理解和实现C++中获取CPU使用率的逻辑。 总的来说，获取CPU使用率需要理解操作系统提供的接口，并能正确处理时间间隔和计算比例。在实际应用中，可以结合这些知识点开发性能监控工具，...
C/C++实现linux和Windows查看系统、进程、服务的内存和CPU使用
08-21
遇到需求写的代码，没那么正规，但也请你尊重作者 C/C++实现linux和Windows查看系统、进程、服务的内存和CPU使用情况的源代码，生成的是静态链接库，Windows和Linux下经测试都可用，查看系统、指定名称的服务、指定名称的进程占用CPU和内存，查看方式不是通过程序中运行命令行的方式，而是采用系统提供的接口去查看内核状态 在开发中遇到需要查看这些信息的朋友可以去使用 如有疑问或好的建议请发送邮件至lion_liu_0301@163.com
linux c程序获取cpu使用率及内存使用情况
02-17
linux c程序获取cpu使用率及内存使用情况
WindowsVC++获取多核CPU各核使用率
03-20
《Windows系统CPU内存网络性能统计第三篇 CPU 多核CPU各核使用率 C#》 http://blog.csdn.net/morewindows/article/details/8678382 配套程序，能获取多核CPU各核的使用率，已经测试，能在WinXP及Win7运行。
linux cpu使用率，内存使用率 api
08-10
linux下c/c++ 实现cpu使用率查询，内存使用率查询，当个程序使用查询 主要应用/proc/stat /proc/meminfo /proc/pid/stat /proc/pid/status 等文件中的内容进行计算
使用C++获取指定线程的CPU使用率
12-12
在C++编程中，获取指定线程的CPU使用率...在C++中实现线程CPU使用率的获取涉及到对操作系统特性的深入理解和对系统API的熟练运用。通过上述方法，开发者可以监控程序中特定线程的资源消耗，从而进行更有效的性能优化。
c++ 代码获得linux cpu 当前总使用率
fire_work的专栏
06-12 919
#include <stdio.h> #include <signal.h> #include <cstdlib> #include <fstream> #include <string> #include <vector> #include <list> using namespace std; std::string getValueBySystemCommand(std::string strCommand){ .
Windows下用C语言获取进程cpu使用率，内存使用，IO情况
kimi's blog
05-03 632
一个项目需要，特地写了这些功能的函数。 process_stat.h的内容如下： [code="c"] /** @file * @brief 进程统计信息函数的声明 * @author 张亚霏 * @date 2009/05/03 * @version 0.1 * */ #ifndef PROCESS_STAT_H #define PROCESS_STAT_H ...
c++ 获取windows cpu利用率
mengxingchengshang的博客
07-29 1490
c++ 获取windows cpu利用率 工作中遇到，需要获取本机的cpu利用率，网上查了很多，获取数值大多不准确。在window10系统上得到的cpu利用率都不准确，window7上的准确。 #include <iostream> #include <Windows.h> #include<string> using namespace std; __int64 Filetime2Int64(const FILETIME &ftime) { LARGE_INT
linux C++ 不延时获取CPU占用率
06-01
以下是一个不需要延时获取CPU占用率的C++代码示例： ``` #include #include #include #include #include using namespace std; double GetCPULoad() { ifstream proc_stat("/proc/stat"); string line; ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值