CPU监控的深入探究

在日常工作中，对于 CPU 的监控也是不可缺失的一环，本节将从 CPU 的监控状态和计算服务器当前 CPU 的使用率，两个方面介绍如何实现对于 CPU 使用率的监控。

CPU 运行状态

CPU 运行可以大致分为以下几个阶段，每个阶段都有其特定的作用和重要性：

• 用户态（User Mode）:

在用户态下，CPU 执行用户程序的指令。这是正常的应用程序代码运行的环境，不直接访问内核或硬件资源。用户程序通过系统调用请求操作系统提供的服务。

• 系统态（System Mode）:

当用户程序需要执行系统调用或响应中断时，CPU 从用户态切换到系统态。在系统态，CPU 可以访问内核和硬件资源，执行特权指令和操作。系统态负责处理文件系统操作、网络通信、设备驱动等任务。

• 中断处理（Interrupt Handling）:

当硬件设备发出中断信号时，CPU 会暂停当前任务，保存当前环境状态，并跳转到中断处理程序。中断处理程序负责响应外部事件，如 I/O 操作完成、用户输入等。

• 内核态（Kernel Mode）:

内核态是系统态的一部分，通常指内核代码执行的状态。在内核态，CPU 运行在最高权限级别，可以执行任何操作，包括管理内存、调度进程、处理错误等。

• 空闲态（Idle Mode）:

当 CPU 没有任务需要执行时，它会进入空闲态。在空闲态，CPU 执行一个特殊的空闲进程，通常只是循环等待新的任务或中断。这样可以节省能源，因为 CPU 在空闲时不会执行任何实际工作。

• 等待 I/O（I/O Wait）:

当 CPU 需要等待 I/O 操作完成时，它会进入等待 I/O 状态。在这段时间里，CPU 几乎不执行任何计算任务，而是等待 I/O 设备的数据传输完成。

• 虚拟化或偷取（Steal/Virtualization）:

在虚拟化环境中，CPU 可以进入偷取状态，这时虚拟机监控器（hypervisor）可能会在物理 CPU 上运行其他客户的操作系统。在偷取状态下，CPU 为其他虚拟机提供服务，而不是当前主机操作系统。

这些阶段是 CPU 在执行任务时可能经历的不同状态，它们共同确保了系统的多任务处理能力、响应性和资源管理效率。在操作系统的调度和管理下，CPU 根据当前的任务和系统需求在这些状态之间切换。

计算服务器当前 CPU 的使用率

计算服务器的 CPU 利用率通常涉及到测量一段时间内 CPU 处于活跃状态（非空闲）的时间比例。以下是计算 CPU 利用率的一般步骤：

1. 收集初始数据：

   首先，你需要获取 CPU 在某个时间点的统计信息。这通常通过读取 /proc/stat 文件来实现，该文件包含了自系统启动以来的 CPU 统计数据。

2. 等待一段时间：

   然后，等待一个特定的时间间隔（例如，1 秒或 5 秒）。这个时间间隔应该根据你的监控需求和系统的变化速度来选择。

3. 收集最终数据：

   在等待了指定的时间间隔后，再次读取 /proc/stat 文件以获取新的 CPU 统计信息。

4. 计算差异：

   对于每个 CPU 核心，计算两次读取之间的差异。这包括用户态时间（user）、系统态时间（system）、空闲时间（idle）、I/O 等待时间（iowait）、中断处理时间（irq）和软中断处理时间（softirq）等。

5. 计算总活跃时间：

   计算每次读取的总活跃时间，即所有非空闲时间的总和。公式为：总活跃时间 = user + system + irq + softirq。

6. 计算总 CPU 时间：

   计算每次读取的总 CPU 时间，即活跃时间和空闲时间的总和。公式为：总 CPU 时间 = 总活跃时间 + idle。

7. 计算利用率：

   使用以下公式计算 CPU 利用率：CPU 利用率 = (总活跃时间 / 总 CPU 时间) * 100%。

8. 平均利用率：

   如果你有多个核心，你需要对每个核心的数据进行平均，以得到整个服务器的 CPU 利用率。

自己写一个监控程序

我们使用 golang 简单写了一个监控服务器 CPU 的程序，如内容如下：

package main

import (
	"fmt"
	"io/ioutil"
	"strconv"
	"strings"
	"time"
)

// CPUStats 保存从 /proc/stat 读取的 CPU 统计信息
type CPUStats struct {
	User    float64
	Nice    float64
	System  float64
	Idle   float64
	IOWait float64
	IRQ     float64
	SoftIRQ float64
	Steal   float64
}

// readCPUStats 从 /proc/stat 读取 CPU 统计信息
func readCPUStats() (*CPUStats, error) {
	content, err := ioutil.ReadFile("/proc/stat")
	if err != nil {
		return nil, err
	}
	lines := strings.Split(string(content), "\n")
	for _, line := range lines {
		if strings.HasPrefix(line, "cpu") {
			fields := strings.Fields(line)
			if len(fields) < 8 {
				continue
			}
			cpuStats := &CPUStats{}
			for i, field := range fields[1:] {
				switch i {
				case 0:
					cpuStats.User, _ = strconv.ParseFloat(field, 64)
				case 1:
					cpuStats.Nice, _ = strconv.ParseFloat(field, 64)
				case 2:
					cpuStats.System, _ = strconv.ParseFloat(field, 64)
				case 3:
					cpuStats.Idle, _ = strconv.ParseFloat(field, 64)
				case 4:
					cpuStats.IOWait, _ = strconv.ParseFloat(field, 64)
				case 5:
					cpuStats.IRQ, _ = strconv.ParseFloat(field, 64)
				case 6:
					cpuStats.SoftIRQ, _ = strconv.ParseFloat(field, 64)
				case 7:
					cpuStats.Steal, _ = strconv.ParseFloat(field, 64)
				}
				return cpuStats, nil
			}
		}
	}
	return nil, fmt.Errorf("failed to parse /proc/stat")
}

// Total 计算 CPUStats 的总时间
func (c *CPUStats) Total() float64 {
	return c.User + c.Nice + c.System + c.Idle + c.IOWait + c.IRQ + c.SoftIRQ + c.Steal
}

// calculateCPUUsage 计算两次读取之间的 CPU 使用率变化
func calculateCPUUsage(prev, current *CPUStats, duration time.Duration) (float64, error) {
	totalPrev := prev.Total()
	totalCurrent := current.Total()
	idleDelta := current.Idle - prev.Idle
	activeDelta := totalCurrent - idleDelta - totalPrev

	if totalCurrent == 0 {
		return 0, fmt.Errorf("no CPU activity detected")
	}

	usage := (activeDelta / totalCurrent) * 100
	return usage, nil
}

func main() {
	// 读取初始 CPU 统计信息
	prevCPUStats, err := readCPUStats()
	if err != nil {
		fmt.Println("Error reading initial CPU stats:", err)
		return
	}

	// 等待一段时间
	time.Sleep(1 * time.Second)

	// 读取新的 CPU 统计信息
	currentCPUStats, err := readCPUStats()
	if err != nil {
		fmt.Println("Error reading current CPU stats:", err)
		return
	}

	// 计算 CPU 使用率变化
	usage, err := calculateCPUUsage(prevCPUStats, currentCPUStats, 1*time.Second)
	if err != nil {
		fmt.Println("Error calculating CPU usage:", err)
		return
	}

	fmt.Printf("CPU Usage: %.2f%%\n", usage)
}

在 Linux 服务器上安装好 golang 环境，可以参考文档，然后执行以下命令运行程序：

mkdir cpu
cd cpu
vim main.go ##将上面代码复制到 main.go 中
go mod init cpu
go build . 
./cpu 

## 输出如下 CPU Usage: 0.30%

这段代码的主要逻辑就是检测 /proc/stat 中 CPU 字段的变化，/proc/state 的内容如下：

cpu  713 0 870 129972 206 0 43 0 0 0   ## CPU 后面的每个值分别代表了，用户空间占用的 CPU 时间、系统空间占用的 CPU 时间、 虚拟机占用的 CPU 时间、空闲时间，系统没有运行任何进程、硬件中断时间、软件中断时间、调度时间，用于处理任务切换、其他时间，可能包括一些特殊情况下的 CPU 时间、后续的 0 表示没有发生特定的事件，如处理器休眠等
cpu0 326 0 386 65001 80 0 23 0 0 0
cpu1 387 0 484 64970 126 0 20 0 0 0

代码解析

主要变量：

- totalPrev:

	totalPrev 变量存储了上一次读取的 CPU 统计数据的总时间。这是通过调用 prev 结构体的 Total() 方法得到的，该方法计算了 prev 结构体中所有 CPU 时间统计字段的和（包括用户态时间 User、系统态时间 System、空闲时间 Idle 等）。

- totalCurrent:

	totalCurrent 变量存储了当前（或最近一次）读取的 CPU 统计数据的总时间。这同样是通过调用 current 结构体的 Total() 方法得到的。这个总时间代表了自系统启动以来到当前时刻的累积 CPU 时间。

- idleDelta:

	idleDelta 变量表示空闲时间的变化量，即当前空闲时间与上次读取的空闲时间之差。这是通过从 current.Idle 中减去 prev.Idle 得到的。空闲时间是指 CPU 没有执行任何任务的时间，包括等待 I/O 操作和其他原因导致的空闲。

- activeDelta：

	activeDelta 变量表示活跃时间的变化量，即在考虑空闲时间后，总 CPU 时间与上次读取的总 CPU 时间之差。这是通过从 totalCurrent 中减去 idleDelta 和 totalPrev 得到的。活跃时间是指 CPU 用于执行任务的时间，包括用户态和系统态下的计算、处理中断、执行软中断等。

主要运算逻辑：

totalPrev := prev.Total()
totalCurrent := current.Total()
idleDelta := current.Idle - prev.Idle
activeDelta := totalCurrent - idleDelta - totalPrev

通过这些计算，我们可以估计在两次读取之间 CPU 被活跃使用的程度。activeDelta 表示在这段时间内 CPU 用于处理任务的时间比例，而 idleDelta 表示 CPU 空闲的时间比例。这些信息可以用来计算 CPU 利用率，即 CPU 活跃时间占总时间的百分比。

为了得到准确的 CPU 利用率，我们需要将 activeDelta 除以 totalCurrent，然后乘以 100，得到一个百分比值。这个值反映了在两次读取之间 CPU 的平均使用情况。如果 activeDelta 接近于零，这意味着在这段时间内 CPU 大部分时间是空闲的；如果 activeDelta 接近于 totalCurrent，这意味着 CPU 在这段时间内几乎一直在执行任务。

后记

prometheus处理proc/stat的代码段