《编程实现获取linux服务器cpu、内存和磁盘使用率》

https://blog.csdn.net/wan_hust/article/details/32314701?utm_medium=distribute.pc_relevant.none-task-blog-2~default~baidujs_title~default-0.control&spm=1001.2101.3001.4242

废话不多说了，直接上代码：

#pragma once
#include <inttypes.h>
#include <iostream>
#if defined(_WIN64) || (_WIN32)
#include <windows.h>
#else
#include <sys/sysinfo.h>
#endif
using namespace std;
namespace robin
{
	class Usage
	{
	public:
		static void init()
		{
		}
		static uint32_t getMemoryUsgae();
		static uint32_t getCpuUsage();


	};

/*
winBase.h
windows.h
MEMORYSTATUS ms;
*/
#if (_WIN64) || (_WIN32)
	uint32_t Usage::getMemoryUsgae()
	{
		MEMORYSTATUS ms;
		::GlobalMemoryStatus(&ms);
		return ms.dwMemoryLoad;
	}

	//CPU使用率；使用方法：直接调用getCpuUsage（）函数
	//原理：记录一定时间内CPU的空闲时间和繁忙时间，然后计算得出
	__int64 CompareFileTime(FILETIME time1, FILETIME time2)
	{
		__int64 a = (__int64)time1.dwHighDateTime << 32 | time1.dwLowDateTime;
		__int64 b = (__int64)time2.dwHighDateTime << 32 | time2.dwLowDateTime;

		return   (b - a);
	}

	uint32_t Usage::getCpuUsage()
	{
		static bool bInit = false;
		static FILETIME pre_idleTime;
		static FILETIME pre_kernelTime;
		static FILETIME pre_userTime;

		FILETIME idleTime;//空闲时间 
		FILETIME kernelTime;//核心态时间 
		FILETIME userTime;//用户态时间 

		bool res = GetSystemTimes(&idleTime, &kernelTime, &userTime);


		__int64 idle = CompareFileTime(pre_idleTime, idleTime);
		__int64 kernel = CompareFileTime(pre_kernelTime, kernelTime);
		__int64 user = CompareFileTime(pre_userTime, userTime);
		
		pre_userTime = userTime;
		pre_kernelTime = kernelTime;
		pre_idleTime = idleTime;

		if (bInit == false)
		{
			bInit = true;
			return 0;
		}

		if ((kernel + user) == 0)
			return 0;

		int cpu_occupancy_rate = double(kernel + user - idle) * 100.0 / double(kernel + user);
		//（总的时间 - 空闲时间）/ 总的时间 = 占用CPU时间的比率，即占用率

		//int cpu_idle_rate = idle * 100.0 / (kernel + user);
		//空闲时间 / 总的时间 = 闲置CPU时间的比率，即闲置率 

		//int cpu_kernel_rate = kernel * 100 / (kernel + user);
		//核心态时间 / 总的时间 = 核心态占用的比率 

		//int cpu_user_rate = user * 100 / (kernel + user);
		//用户态时间 / 总的时间 = 用户态占用的比率 

		/*cout << "CPU占用率：" << cpu_occupancy_rate << "%" << endl
			<< "CPU闲置率：" << cpu_idle_rate << "%" << endl
			<< "核心态占比率：" << cpu_kernel_rate << "%" << endl
			<< "用户态占比率：" << cpu_user_rate << "%" << endl << endl;*/

		return cpu_occupancy_rate;
	}
#else  // linux

	uint32_t Usage::getMemoryUsgae()
	{
		struct sysinfo tmp;
		int ret = sysinfo(&tmp);
		uint32_t percent;
		if (ret == 0)
		{
			double t = tmp.freeram;
			t = t * 100.0 / tmp.totalram;
			return 100 - t;
		}

		return 0;
	}
	typedef struct _SysCPUInfo
	{
		char name[260];
		uint64_t user;
		uint64_t  nic;
		uint64_t system;
		uint64_t idle;
	}SysCPUInfo;

	void GetHostCPUInfo(SysCPUInfo *cpuinfo)
	{

		FILE 	*fd;
		char	buff[256];
		memset(buff, '\0', 256);

		fd = fopen("/proc/stat", "r");
		fgets(buff, sizeof(buff), fd);

		sscanf(buff, "%s %lu %lu %lu %lu",
			(char *)&cpuinfo->name,
			&cpuinfo->user,
			&cpuinfo->nic,
			&cpuinfo->system,
			&cpuinfo->idle);
		fclose(fd);

	}
	uint32_t Usage::getCpuUsage()
	{
		static uint64_t old_user;
		static uint64_t old_system;
		static uint64_t old_nic;
		static uint64_t old_idle;

		static bool bInit = false;
		
		SysCPUInfo  curInfo;
		GetHostCPUInfo(&curInfo);

		if (bInit == false)
		{
			old_user = curInfo.user;
			old_system = curInfo.system;
			old_idle = curInfo.idle;
			old_nic = curInfo.nic;

			bInit = true;
			return 0;
		}
		
		float cpu_use = 0.0;
		uint64_t old_CPU_Time = (uint64_t)(old_user + old_nic + old_system + old_idle);
		uint64_t new_CPU_Time = (uint64_t)(curInfo.user + curInfo.nic + curInfo.system + curInfo.idle);
		
		uint64_t usr_Time_Diff = (uint64_t)(curInfo.user - old_user);
		uint64_t sys_Time_Diff = (uint64_t)(curInfo.system - old_system);
		uint64_t nic_Time_Diff = (uint64_t)(curInfo.nic - old_nic);

		if ((new_CPU_Time - old_CPU_Time) != 0)
			cpu_use = (double)100.0 * (usr_Time_Diff + sys_Time_Diff + nic_Time_Diff) / (new_CPU_Time - old_CPU_Time);
		else
			cpu_use = 0.0;

		old_user = curInfo.user;
		old_system = curInfo.system;
		old_idle = curInfo.idle;
		old_nic = curInfo.nic;
		return cpu_use;
	}
	
	/*
	void testLinux()
	{
		struct timespec req;
		req.tv_sec = 1;
		req.tv_nsec = 0;
		struct timespec rem;


		int cpuPer = getCpuUsage();
		for (int i=0; i<100; i++)
		{
				int ret = nanosleep(&req, &rem);
				cpuPer = getCpuUsage();
				printf("cpu = %lu\n", cpuPer);
		}
	}
	*/

	

#endif


}

调用时候，在线程中设置定时器，或者 sleep一段时间，调用函数，返回百分比；

备注：CPU的占用率，首次调用会返回0。