CPU

2024年12月25日

柏拉文

越努力，越幸运

一、CPU 负载

1.1 认识

CPU 负载 描述的是系统中等待 CPU 执行的任务数量。一般来说，它可以理解为系统队列中任务的数量，包括正在运行和等待运行的任务。CPU 负载的数值越高，说明系统任务越多，CPU 负载越重；数值越低，说明系统任务较少，CPU 有更多的闲暇时间。

CPU 负载 通常以平均值的形式显示，分为 1 分钟平均负载、5 分钟平均负载 和 15 分钟平均负载。这些数值分别表示系统在过去 1 分钟、5 分钟 和 15 分钟内 的平均负载。这个平均值可以帮助我们判断系统的负载趋势和波动情况。

CPU 负载 反映的是系统的整体负载情况，表示系统的繁忙程度，包括等待 CPU 和 I/O 资源的进程。负载不一定与 CPU 使用率直接相关。

1.2 公式

负载值 = (就绪队列中的进程数 + 正在运行的进程数) / CPU 数量

负载值大致反映了以下情况：

如果负载值小于 CPU 数量，说明系统处于轻度负载状态，CPU 使用率低。
如果负载值等于 CPU 数量，系统负载正常，CPU 正常工作。
如果负载值大于 CPU 数量，表示系统压力过大，可能会发生任务排队等情况。

1.3 计算

我们可以通过 Node.js 中的 os.loadavg() 方法获取系统的负载平均值（即 1 分钟、5 分钟和 15 分钟的负载平均值）：

const os = require('os');

// 获取系统的负载平均值（1分钟，5分钟，15分钟）
const loadAvg = os.loadavg();

// 输出负载平均值
console.log('1 minute load average:', loadAvg[0]);
console.log('5 minute load average:', loadAvg[1]);
console.log('15 minute load average:', loadAvg[2]);

os.loadavg()[0]：1 分钟的负载平均值。
os.loadavg()[1]：5 分钟的负载平均值。
os.loadavg()[2]：15 分钟的负载平均值。

二、CPU 使用率

2.1 认识

CPU 使用率 是一个衡量计算机中央处理单元（CPU）在给定时间内有多忙碌的指标。它表示在 CPU 能够使用的时间里，CPU 实际上被使用的时间百分比。简单来说，CPU 使用率反映了计算机的处理能力被消耗的程度。

0% CPU 使用率意味着 CPU 完全空闲，没有任何任务在运行
100% CPU 使用率意味着 CPU 在该时刻完全处于工作状态，没有闲置

CPU 使用率 主要关注的是 CPU 资源的实际使用情况，反映了 CPU 被占用的百分比。如果系统 CPU 使用率很高，通常意味着系统忙于处理任务。

2.2 公式

CPU 使用率 通常是通过以下方式计算的：

用户态（User Time）：CPU 执行用户级程序的时间。
系统态（System Time）：CPU 执行内核操作的时间。
空闲态（Idle Time）：CPU 没有执行任何任务的时间。
中断时间（IRQ Time）：处理硬件中断的时间。

CPU 使用率 的计算公式一般是：

CPU 使用率 = (总时间 - 空闲时间) / 总时间 * 100

空闲时间：所有 CPU 核心的 idle 时间的总和。
总时间：包括所有 CPU 核心的 user、system 和 idle 时间的总和。

2.3 计算

在 Node.js 中，我们可以使用 os.cpus() 获取每个 CPU 核心的时间数据，然后根据上述公式来计算 CPU 使用率。

const os = require('os');

// 计算 CPU 使用率
function getCpuUsage() {
  const cpus = os.cpus();
  let totalIdle = 0;
  let totalTick = 0;

  cpus.forEach(cpu => {
    const times = cpu.times;
    totalIdle += times.idle;
    totalTick += Object.values(times).reduce((acc, val) => acc + val, 0);
  });

  // 计算 CPU 使用率
  const idle = totalIdle / cpus.length;
  const total = totalTick / cpus.length;
  const percentage = (1 - idle / total) * 100;

  return percentage;
}

setInterval(() => {
  const cpuUsage = getCpuUsage();
  console.log(`CPU Usage: ${cpuUsage.toFixed(2)}%`);
}, 1000);

获取每个 CPU 核心的 user、system 和 idle 时间。
计算所有 CPU 核心的总的 idle 和 total 时间。
使用公式 (1 - idle / total) * 100 计算 CPU 使用率。

三、process_cpu_seconds_total

3.1 认识

process_cpu_seconds_total (总 CPU 时间)：这个指标将用户 CPU 时间和系统 CPU 时间相加，表示 Node.js 进程在用户态和系统态的总 CPU 使用时间，单位为秒。

3.2 计算

在 Node.js 中，我们可以通过 process.cpuUsage() 方法来获取进程的 CPU 使用情况，特别是用户模式和系统模式下的时间。Node.js 提供了 process.cpuUsage() 来获取当前进程的 CPU 使用情况。该方法返回的结果是一个对象，包含 user 和 system 属性，单位为微秒（µs）。process.cpuUsage()：返回一个对象，包含两个属性：

user：用户模式 CPU 时间（微秒）
system：系统模式 CPU 时间（微秒）

计算逻辑: cpu_user_seconds 和 cpu_system_seconds：每次调用 process.cpuUsage() 获取当前时间差，再将其转化为秒（通过除以 1,000,000）; cpu_user_seconds_total：为了跟踪自进程启动以来的总用户模式 CPU 时间，我们需要累积 cpu_user_seconds。

const process = require('process');

// 用来跟踪上次的 CPU 使用情况
let lastCpuUsage = process.cpuUsage();
let totalUserSeconds = 0;
let totalSystemSeconds = 0;

// 每秒更新一次 CPU 使用数据
function updateCpuUsage() {
  // 获取当前 CPU 使用时间（以微秒为单位）
  const currentCpuUsage = process.cpuUsage(lastCpuUsage);

  // 计算当前周期的用户模式时间（单位：秒）
  const userSeconds = currentCpuUsage.user / 1e6; // 微秒转换为秒
  // 计算当前周期的系统模式时间（单位：秒）
  const systemSeconds = currentCpuUsage.system / 1e6; // 微秒转换为秒

  // 更新累计的用户和系统模式时间
  totalUserSeconds += userSeconds;
  totalSystemSeconds += systemSeconds;

  // 输出当前周期的 CPU 使用情况
  console.log(`CPU User Seconds: ${userSeconds.toFixed(6)} seconds`);
  console.log(`CPU System Seconds: ${systemSeconds.toFixed(6)} seconds`);

  // 输出自进程启动以来的累计用户模式 CPU 时间
  console.log(`Total CPU User Seconds: ${totalUserSeconds.toFixed(6)} seconds`);
  
  // 记录下当前的 CPU 使用时间，以便下次计算差值
  lastCpuUsage = process.cpuUsage();
}

// 每秒钟更新一次
setInterval(updateCpuUsage, 1000);

process.cpuUsage(): 返回的是一个对象，包含用户模式和内核模式的 CPU 时间。
lastCpuUsage: 用来记录上次调用 process.cpuUsage() 时的 CPU 使用时间。
process.cpuUsage(lastCpuUsage): 调用 process.cpuUsage(lastCpuUsage) 时，返回的是自上次调用以来的 CPU 使用时间差。
userSeconds = currentCpuUsage.user / 1e6: 计算当前周期的用户模式和系统模式的 CPU 时间，单位是秒。因为 process.cpuUsage() 返回的值是微秒（1 微秒 = 1/1,000,000 秒），所以需要除以 1e6（即 1,000,000）来将其转换为秒。
totalUserSeconds += userSeconds: 用来计算累计的 CPU 时间。这些是从进程启动到当前时刻的总用户模式和系统模式的 CPU 时间。

四、process_cpu_user_seconds_total

4.1 认识

process_cpu_user_seconds_total (用户 CPU 时间)：这个指标用于跟踪 Node.js 进程在用户态（用户空间）花费的总 CPU 时间，单位为秒。用户态是指进程执行应用程序代码的时间。

4.2 计算

user：用户模式 CPU 时间（微秒）
system：系统模式 CPU 时间（微秒）

const process = require('process');

// 用来跟踪上次的 CPU 使用情况
let lastCpuUsage = process.cpuUsage();
let totalUserSeconds = 0;
let totalSystemSeconds = 0;

// 每秒更新一次 CPU 使用数据
function updateCpuUsage() {
  // 获取当前 CPU 使用时间（以微秒为单位）
  const currentCpuUsage = process.cpuUsage(lastCpuUsage);

  // 计算当前周期的用户模式时间（单位：秒）
  const userSeconds = currentCpuUsage.user / 1e6; // 微秒转换为秒
  // 计算当前周期的系统模式时间（单位：秒）
  const systemSeconds = currentCpuUsage.system / 1e6; // 微秒转换为秒

  // 更新累计的用户和系统模式时间
  totalUserSeconds += userSeconds;
  totalSystemSeconds += systemSeconds;

  // 输出当前周期的 CPU 使用情况
  console.log(`CPU User Seconds: ${userSeconds.toFixed(6)} seconds`);
  console.log(`CPU System Seconds: ${systemSeconds.toFixed(6)} seconds`);

  // 输出自进程启动以来的累计用户模式 CPU 时间
  console.log(`Total CPU User Seconds: ${totalUserSeconds.toFixed(6)} seconds`);
  
  // 记录下当前的 CPU 使用时间，以便下次计算差值
  lastCpuUsage = process.cpuUsage();
}

// 每秒钟更新一次
setInterval(updateCpuUsage, 1000);

process.cpuUsage(): 返回的是一个对象，包含用户模式和内核模式的 CPU 时间。
lastCpuUsage: 用来记录上次调用 process.cpuUsage() 时的 CPU 使用时间。
process.cpuUsage(lastCpuUsage): 调用 process.cpuUsage(lastCpuUsage) 时，返回的是自上次调用以来的 CPU 使用时间差。
userSeconds = currentCpuUsage.user / 1e6: 计算当前周期的用户模式和系统模式的 CPU 时间，单位是秒。因为 process.cpuUsage() 返回的值是微秒（1 微秒 = 1/1,000,000 秒），所以需要除以 1e6（即 1,000,000）来将其转换为秒。
totalUserSeconds += userSeconds: 用来计算累计的 CPU 时间。这些是从进程启动到当前时刻的总用户模式和系统模式的 CPU 时间。

五、process_cpu_system_seconds_total

5.1 认识

process_cpu_system_seconds_total (系统 CPU 时间)：该指标用于跟踪 Node.js 进程在内核态（操作系统内核空间）花费的总 CPU 时间，单位为秒。系统态时间通常用于处理系统调用（如文件读写、网络请求等）和其他内核任务。

5.2 计算

user：用户模式 CPU 时间（微秒）
system：系统模式 CPU 时间（微秒）

const process = require('process');

// 用来跟踪上次的 CPU 使用情况
let lastCpuUsage = process.cpuUsage();
let totalUserSeconds = 0;
let totalSystemSeconds = 0;

// 每秒更新一次 CPU 使用数据
function updateCpuUsage() {
  // 获取当前 CPU 使用时间（以微秒为单位）
  const currentCpuUsage = process.cpuUsage(lastCpuUsage);

  // 计算当前周期的用户模式时间（单位：秒）
  const userSeconds = currentCpuUsage.user / 1e6; // 微秒转换为秒
  // 计算当前周期的系统模式时间（单位：秒）
  const systemSeconds = currentCpuUsage.system / 1e6; // 微秒转换为秒

  // 更新累计的用户和系统模式时间
  totalUserSeconds += userSeconds;
  totalSystemSeconds += systemSeconds;

  // 输出当前周期的 CPU 使用情况
  console.log(`CPU User Seconds: ${userSeconds.toFixed(6)} seconds`);
  console.log(`CPU System Seconds: ${systemSeconds.toFixed(6)} seconds`);

  // 输出自进程启动以来的累计用户模式 CPU 时间
  console.log(`Total CPU User Seconds: ${totalUserSeconds.toFixed(6)} seconds`);
  
  // 记录下当前的 CPU 使用时间，以便下次计算差值
  lastCpuUsage = process.cpuUsage();
}

// 每秒钟更新一次
setInterval(updateCpuUsage, 1000);

process.cpuUsage(): 返回的是一个对象，包含用户模式和内核模式的 CPU 时间。
lastCpuUsage: 用来记录上次调用 process.cpuUsage() 时的 CPU 使用时间。
process.cpuUsage(lastCpuUsage): 调用 process.cpuUsage(lastCpuUsage) 时，返回的是自上次调用以来的 CPU 使用时间差。
userSeconds = currentCpuUsage.user / 1e6: 计算当前周期的用户模式和系统模式的 CPU 时间，单位是秒。因为 process.cpuUsage() 返回的值是微秒（1 微秒 = 1/1,000,000 秒），所以需要除以 1e6（即 1,000,000）来将其转换为秒。
totalUserSeconds += userSeconds: 用来计算累计的 CPU 时间。这些是从进程启动到当前时刻的总用户模式和系统模式的 CPU 时间。

一、CPU 负载​

1.1 认识​

1.2 公式​

1.3 计算​

二、CPU 使用率​

2.1 认识​

2.2 公式​

2.3 计算​

三、process_cpu_seconds_total​

3.1 认识​

3.2 计算​

四、process_cpu_user_seconds_total​

4.1 认识​

4.2 计算​

五、process_cpu_system_seconds_total​

5.1 认识​

5.2 计算​