1. 从零开始：为什么你需要关注CPU使用率？

大家好，我是老张，一个在运维和性能测试领域摸爬滚打了十多年的老码农。今天想和大家深入聊聊一个看似简单，实则暗藏玄机的话题：在Python里，如何精准地监控CPU使用率。你可能觉得，这还不简单？不就是个系统监控嘛。但在我经手的无数项目中，恰恰是这个“简单”的指标，坑过不少新手，甚至一些有经验的开发者。

想象一下这些场景：你写了一个后台数据处理脚本，跑起来总觉得慢，但代码逻辑又看不出毛病；你负责维护一个Web服务，半夜突然收到告警说CPU飙到100%，却不知道是哪个进程、哪段代码惹的祸；或者你在做性能压测，需要精确评估一段算法在不同负载下的CPU开销。这时候，一个精准、可靠的CPU使用率监控工具，就是你定位问题的“火眼金睛”。

在Python生态里，psutil库无疑是完成这个任务的首选神器。它跨平台、功能强大，而其中的cpu_percent()方法，则是获取CPU使用率的核心。但据我观察，很多人只是照猫画虎地调用一下，对它的两个关键参数interval和percpu的理解停留在表面，更别提那个经典的“首次调用返回0.0”的坑了。结果就是，采集到的数据要么不准，要么毫无意义，根本没法用于严肃的性能分析和监控告警。

所以，这篇文章的目的，就是带你彻底吃透psutil.cpu_percent()。我会结合我这些年踩过的坑和积累的最佳实践，从原理到参数，从基础调用到高级场景，手把手教你搭建一套精准、高效的CPU监控方案。无论你是想优化自己的脚本，还是构建企业级的监控系统，这里面的门道都值得你花时间掌握。

2. 庖丁解牛：深入理解cpu_percent()的工作原理与参数

要玩转一个工具，首先得理解它到底是怎么工作的。psutil.cpu_percent(interval=None, percpu=False)这个方法，表面上只是返回一个百分比数字，但其背后的计算逻辑，直接决定了你数据的准确性。

2.1 核心参数interval：时间窗口的艺术

interval参数是cpu_percent()的灵魂，它定义了计算使用率的时间窗口。但这里有两种截然不同的模式，很多人一开始就搞混了。

模式一：即时快照模式（interval=0.0 或 None） 当你设置interval=0.0或者直接不传（默认为None）时，方法的行为是：比较当前时刻与上一次调用该方法（或导入psutil模块）时的CPU时间差。然后立刻返回这个时间差内的CPU使用率百分比。

这里就引出了那个著名的“坑”：第一次调用永远返回0.0。为什么？因为第一次调用时，没有“上一次”的状态可以比较，psutil只能将当前时刻记录为初始状态，然后计算“当前时刻到当前时刻”的CPU时间差，那当然是0，所以使用率就是0.0%。这个0.0%是一个无意义的占位符，你必须忽略它。从第二次调用开始，才是真正有意义的、基于两次调用时间间隔的计算结果。

我举个例子。假设你写了一个循环，每秒打印一次CPU使用率：

import psutil, time

for i in range(5):
    usage = psutil.cpu_percent(interval=None) # 使用默认值None
    print(f"第{i+1}次调用: {usage}%")
    time.sleep(1)

输出可能会是这样：

第1次调用: 0.0%
第2次调用: 2.5%
第3次调用: 1.8%
第4次调用: 15.3%
第5次调用: 0.7%

看到了吗？第一次的0.0%就是个烟雾弹。这种模式的好处是非阻塞、响应快，适合在需要频繁采样、又不能被长时间阻塞的场景中使用，比如一个实时刷新的监控仪表盘。但缺点也很明显：采样间隔完全由你的调用频率控制，如果两次调用间隔太短（比如小于0.1秒），系统调度器可能还没来得及累计足够的CPU时间，导致计算结果波动巨大甚至不准。所以官方文档也建议，在这种模式下，调用间隔最好不低于0.1秒。

模式二：阻塞采样模式（interval > 0.0） 当你给interval传递一个大于0的数值（比如1.0）时，方法的行为就变了：它会阻塞（等待）你指定的秒数，然后在这段“等待期”内主动测量CPU的使用情况，最后返回这个时间段内的平均使用率。

import psutil

# 这行代码会阻塞大约1秒钟
usage = psutil.cpu_percent(interval=1.0)
print(f"过去1秒内的平均CPU使用率: {usage}%")

这种模式下，第一次调用就是有效的，因为它内部会先取一个开始状态，然后睡眠（interval秒），醒来后再取一个结束状态，计算这段时间内的使用率。它的优点是数据非常稳定和准确，因为测量窗口是固定的、由方法内部控制的。特别适合做性能基准测试，比如你想精确知道某段代码运行期间消耗了多少CPU资源。缺点就是会阻塞你的程序，在需要高并发的场景中要谨慎使用。

那么，到底该用哪种模式呢？我的经验是：

• 做性能剖析或基准测试：用 interval=1.0 或更长，获取稳定平均值。
• 做实时监控或告警：用 interval=None，并在一个独立的线程或异步任务里以固定频率（如每秒）调用，但要记得丢弃第一次的结果。
• 不确定时：优先使用 interval=1.0，准确性更有保障。

2.2 参数percpu：是看整体还是拆开看？

percpu这个布尔参数决定了你是要看整个系统的CPU总使用率，还是每个逻辑CPU核心的详细情况。默认是False，即返回一个总的浮点数。

import psutil

# 查看总体使用率（默认）
total_usage = psutil.cpu_percent(interval=1)
print(f"总体CPU使用率: {total_usage}%")

# 查看每个CPU核心的使用率
per_cpu_usage = psutil.cpu_percent(interval=1, percpu=True)
print(f"每个核心使用率: {per_cpu_usage}")
# 输出可能类似：[12.5, 3.1, 45.6, 8.9] （对于4核CPU）

把percpu设为True后，返回值就变成了一个列表。这个列表的顺序是固定的，对应着你系统里逻辑CPU核心的编号（通常是0, 1, 2...）。这个功能在诊断问题时有奇效。

比如，有一次我遇到一个服务，总体CPU使用率才40%，看起来不忙，但服务响应却很慢。我用percpu=True一看，发现其中一个核心的使用率持续在90%以上，而其他核心都很闲。这说明程序可能是单线程的，或者有某个热点线程被死死地绑定在了一个核心上，形成了瓶颈。如果没有看每个核心的数据，这个“局部热点”问题就被总体数据给平均掉了，很难发现。

所以，在以下场景，我强烈建议使用percpu=True：

1. 诊断多线程程序的负载均衡问题：看工作是否均匀分配到了各个核心。
2. 定位“单核跑满”问题：有些软件或驱动有bug，会导致一个核心异常繁忙。
3. 精细化资源调度：在容器或虚拟化环境里，你可能需要根据每个核心的负载来调度任务。

3. 实战演练：避开陷阱，掌握最佳实践

知道了原理，我们就要上手用了。这一部分，我会分享几个最实用的代码示例和关键技巧，帮你把cpu_percent()用得既准又稳。

3.1 基础用法与“首次调用0.0”的完美解决方案

我们先解决那个恼人的首次调用问题。对于interval=None的模式，标准的处理流程是这样的：

import psutil
import time

def get_cpu_usage_non_blocking():
    """
    非阻塞方式获取CPU使用率，自动处理首次调用无效值。
    返回：CPU使用率百分比（浮点数）
    """
    # 第一次调用，用于“预热”，获取到的0.0直接丢弃
    psutil.cpu_percent(interval=None)

    # 等待一个极短的时间，确保系统有时间累计CPU时间。
    # 这里用0.1秒是文档建议的最小值，对于大多数场景足够了。
    time.sleep(0.1)

    # 第二次调用，获取的是过去0.1秒内的使用率，这才是有效值
    usage = psutil.cpu_percent(interval=None)
    return usage

# 使用示例
if __name__ == '__main__':
    # 模拟一个监控循环
    for i in range(10):
        cpu_usage = get_cpu_usage_non_blocking()
        print(f"[{i}] CPU使用率: {cpu_usage:.1f}%")
        time.sleep(0.9) # 控制整体采样频率约为1秒一次

这个get_cpu_usage_non_blocking函数封装了最佳实践：一次预热调用加一个短暂等待。这样你每次调用这个函数，得到的就是一个有效的、反映最近0.1秒负载的瞬时值。如果你觉得0.1秒的等待在超高频采样中无法接受，可以适当缩短，但要知道精度可能会下降。

对于interval>0的阻塞模式，就简单多了，因为它没有首次调用的问题：

def get_cpu_usage_blocking(sample_interval=1.0):
    """
    阻塞方式获取CPU使用率，数据更平滑准确。
    参数：sample_interval - 采样间隔（秒）
    返回：CPU使用率百分比（浮点数）
    """
    usage = psutil.cpu_percent(interval=sample_interval)
    return usage

# 使用示例：测量接下来3秒内的平均CPU负载
print("开始测量3秒内的平均CPU使用率...")
usage = get_cpu_usage_blocking(3.0)
print(f"结果: {usage}%")

3.2 构建一个简单的实时CPU监控器

让我们把这些知识组合起来，写一个实用的、控制台版的实时CPU监控小工具。这个工具会同时显示总体使用率和每个核心的使用率，并且用简单的文本图表让数据更直观。

import psutil
import time
import os

def clear_screen():
    """清空控制台屏幕，兼容Windows和Linux/macOS"""
    os.system('cls' if os.name == 'nt' else 'clear')

def draw_simple_bar(percentage, width=50):
    """用文本画一个简单的进度条"""
    filled = int(width * percentage / 100)
    bar = '█' * filled + '░' * (width - filled)
    return f"[{bar}] {percentage:5.1f}%"

def monitor_cpu(interval_sec=1, duration_sec=30):
    """
    实时监控CPU使用率
    参数：
        interval_sec: 每次采样的间隔（秒）
        duration_sec: 总监控时长（秒），设为None则一直运行
    """
    print("启动CPU实时监控器... (按 Ctrl+C 退出)")
    print("总体使用率 | 每个核心使用率")
    print("-" * 60)

    # 初始化：丢弃第一次无效读数（针对非阻塞模式预热）
    # 注意：这里我们为了实时性，采用interval=None的非阻塞模式，但自己控制采样间隔。
    psutil.cpu_percent(interval=None)
    time.sleep(0.1) # 预热等待

    start_time = time.time()
    try:
        while True:
            if duration_sec and (time.time() - start_time) > duration_sec:
                print(f"\n监控时长 {duration_sec} 秒已到，结束。")
                break

            # 获取总体使用率（非阻塞）
            total_usage = psutil.cpu_percent(interval=None)
            # 获取每个核心使用率（非阻塞）
            per_cpu_usage = psutil.cpu_percent(interval=None, percpu=True)

            clear_screen() # 清屏实现“动态刷新”效果
            print(f"CPU使用率监控 - 采样间隔: ~{interval_sec}秒")
            print(f"运行时间: {int(time.time() - start_time)}秒")
            print("=" * 60)
            print(f"总体: {draw_simple_bar(total_usage)}")
            print("-" * 60)
            for i, core_usage in enumerate(per_cpu_usage):
                print(f"Core {i:2d}: {draw_simple_bar(core_usage)}")

            # 等待到下一个采样点
            time.sleep(interval_sec - 0.1) # 减去预热等待的0.1秒，尽量让采样周期均匀
    except KeyboardInterrupt:
        print("\n\n监控被用户中断。")

if __name__ == '__main__':
    # 监控30秒，每秒刷新一次
    monitor_cpu(interval_sec=1, duration_sec=30)

这个脚本虽然简单，但已经具备了核心功能。它用非阻塞模式快速采样，用进度条可视化数据，还能实时刷新。你可以根据需要修改interval_sec来调整刷新频率，或者把duration_sec设为None让它一直跑下去。这是一个非常好的起点，你可以基于它添加更多功能，比如将数据写入日志文件、设置使用率阈值触发告警等。

3.3 进阶技巧：在性能测试中关联进程与CPU

单独看系统CPU使用率有时还不够，我们常常需要知道是哪个进程、哪段代码导致了高CPU。这时候，就需要把psutil的进程监控功能和cpu_percent结合起来。

假设我们想测试自己写的一个函数heavy_computation()的CPU消耗，我们可以这样做：

import psutil
import time
import threading

def heavy_computation():
    """一个模拟的耗时计算函数"""
    result = 0
    for i in range(10**7):
        result += i * i
    return result

def monitor_process_cpu(pid, interval=0.5, duration=10):
    """
    监控指定进程的CPU使用率
    参数：
        pid: 进程ID
        interval: 监控采样间隔
        duration: 总监控时长
    """
    process = psutil.Process(pid)
    print(f"开始监控进程 PID={pid} ({process.name()}) 的CPU使用率...")
    cpu_percentages = []
    
    end_time = time.time() + duration
    while time.time() < end_time:
        try:
            # 使用interval=0.0获取进程自上次调用后的CPU时间百分比
            # 注意：进程的cpu_percent也有首次调用为0的问题
            cpu_percent = process.cpu_percent(interval=None)
            cpu_percentages.append(cpu_percent)
            print(f"  -> 进程CPU: {cpu_percent:.1f}%")
        except (psutil.NoSuchProcess, psutil.AccessDenied):
            print("进程已结束或无权访问。")
            break
        time.sleep(interval)
    
    if cpu_percentages:
        avg_cpu = sum(cpu_percentages[1:]) / len(cpu_percentages[1:]) # 忽略第一个无效值
        print(f"\n监控结束。进程平均CPU使用率: {avg_cpu:.2f}%")

def main():
    print("启动性能测试...")
    
    # 1. 先获取测试前的系统空闲CPU作为参考
    print("测量系统基础CPU负载...")
    time.sleep(1)
    psutil.cpu_percent(interval=None) # 预热
    time.sleep(0.5)
    baseline_system_cpu = psutil.cpu_percent(interval=None)
    print(f"系统基础CPU负载约为: {baseline_system_cpu:.1f}%")
    
    # 2. 启动一个线程来运行耗时函数，并获取其进程ID
    def run_computation():
        result = heavy_computation()
        print(f"计算完成，结果: {result}")
    
    print("\n启动计算任务...")
    computation_thread = threading.Thread(target=run_computation)
    computation_thread.start()
    
    # 给线程一点时间启动并获取其PID（通过当前进程的子进程信息，这里简化处理）
    # 注意：多线程在Linux下共享同一个PID，这里仅为示例。更准确的做法是用多进程。
    time.sleep(0.1)
    current_process = psutil.Process()
    children = current_process.children(recursive=True)
    if children:
        target_pid = children[0].pid
    else:
        # 如果没找到子进程，就监控当前进程自身（对于多线程示例）
        target_pid = os.getpid()
    
    # 3. 在另一个线程中监控该进程的CPU
    monitor_thread = threading.Thread(target=monitor_process_cpu, args=(target_pid, 0.3, 8))
    monitor_thread.start()
    
    # 4. 同时监控整个系统的CPU变化
    print("\n同时监控系统总体CPU使用率:")
    psutil.cpu_percent(interval=None) # 预热系统CPU统计
    time.sleep(0.2)
    system_readings = []
    for _ in range(20): # 监控大约6秒
        sys_cpu = psutil.cpu_percent(interval=None)
        system_readings.append(sys_cpu)
        print(f"  -> 系统CPU: {sys_cpu:.1f}%")
        time.sleep(0.3)
    
    computation_thread.join()
    monitor_thread.join()
    
    avg_system_cpu = sum(system_readings[1:]) / len(system_readings[1:])
    print(f"\n测试期间系统平均CPU使用率: {avg_system_cpu:.2f}%")
    print(f"与基础负载相比，增加了约 {avg_system_cpu - baseline_system_cpu:.2f}个百分点")

if __name__ == '__main__':
    main()

这个例子稍微复杂些，但它展示了一个强大的模式：将系统级监控与进程级监控关联起来。你可以清晰地看到，当你的heavy_computation函数运行时，不仅它自身进程的CPU使用率上升，整个系统的CPU使用率也会相应增加。这对于定位性能热点、评估程序资源消耗非常有用。

4. 生产环境指南：从脚本到监控系统

掌握了单机上的技巧后，我们可以把目光放得更远。在实际的生产环境中，CPU监控很少是孤立的，它通常是整个可观测性体系的一部分。这里，我分享几个将psutil.cpu_percent集成到更大系统中的思路和片段。

4.1 长期数据收集与日志记录

持续的监控数据对于分析趋势、排查偶发问题至关重要。我们可以写一个轻量的数据收集服务。

import psutil
import time
import json
import logging
from datetime import datetime
from threading import Thread, Event

class CPUMonitorDaemon:
    """
    一个简单的CPU监控守护进程，负责定期收集数据并写入日志。
    """
    def __init__(self, collect_interval=10, log_file='cpu_metrics.log'):
        self.collect_interval = collect_interval # 采集间隔（秒）
        self.log_file = log_file
        self.stop_event = Event()
        self.logger = self._setup_logger()
        
        # 预热
        psutil.cpu_percent(interval=None)
        time.sleep(0.1)

    def _setup_logger(self):
        logger = logging.getLogger('CPU_Monitor')
        logger.setLevel(logging.INFO)
        # 避免重复添加handler
        if not logger.handlers:
            file_handler = logging.FileHandler(self.log_file)
            formatter = logging.Formatter('%(message)s') # 只记录JSON消息本身
            file_handler.setFormatter(formatter)
            logger.addHandler(file_handler)
            logger.propagate = False # 防止传播到root logger
        return logger

    def collect_metrics(self):
        """收集一次CPU指标"""
        timestamp = datetime.utcnow().isoformat() + 'Z'
        total_cpu = psutil.cpu_percent(interval=None)
        per_cpu = psutil.cpu_percent(interval=None, percpu=True)
        
        # 可以轻松扩展其他指标，如内存、磁盘IO等
        metrics = {
            'timestamp': timestamp,
            'cpu_total_percent': total_cpu,
            'cpu_per_core_percent': per_cpu,
            'load_avg': psutil.getloadavg() # 获取系统负载（1,5,15分钟）
        }
        return metrics

    def run(self):
        """主循环"""
        print(f"CPU监控守护进程启动，间隔{self.collect_interval}秒，日志文件: {self.log_file}")
        while not self.stop_event.is_set():
            try:
                metrics = self.collect_metrics()
                # 以JSON格式写入日志，便于后续用ELK、Splunk等工具分析
                self.logger.info(json.dumps(metrics))
            except Exception as e:
                print(f"收集指标时出错: {e}")
            
            # 等待下一个采集周期
            self.stop_event.wait(self.collect_interval)

    def start_in_background(self):
        """在后台线程中启动监控"""
        self.thread = Thread(target=self.run, daemon=True)
        self.thread.start()

    def stop(self):
        """停止监控"""
        self.stop_event.set()
        self.thread.join()
        print("CPU监控守护进程已停止。")

# 使用示例
if __name__ == '__main__':
    daemon = CPUMonitorDaemon(collect_interval=5, log_file='./cpu_monitor.log')
    
    try:
        daemon.start_in_background()
        # 主程序可以继续做其他事情...
        print("主程序正在运行，CPU监控已在后台启动。按 Ctrl+C 停止。")
        while True:
            time.sleep(1)
    except KeyboardInterrupt:
        daemon.stop()

这个守护进程类CPUMonitorDaemon做了几件关键事情：1) 在后台线程中定期运行，不阻塞主程序。2) 以结构化的JSON格式记录数据，方便后续用日志分析工具处理。3) 易于扩展，你可以很方便地添加内存、磁盘、网络等指标的收集。生产环境中，你可能还会把数据直接发送到时序数据库（如InfluxDB、Prometheus）或者消息队列中。

4.2 设置智能告警规则

光收集数据不行，我们还需要在异常时及时告警。一个简单的阈值告警可以这样实现：

import psutil
import time
import smtplib
from email.mime.text import MIMEText
from threading import Lock

class CPUAlertAgent:
    """
    CPU使用率告警代理，支持阈值检查和冷却时间。
    """
    def __init__(self, alert_threshold=80.0, sustained_seconds=30, cool_down_seconds=300):
        """
        参数：
            alert_threshold: 告警阈值（百分比）
            sustained_seconds: 持续超过阈值多少秒才触发告警
            cool_down_seconds: 触发告警后的冷却时间（秒），防止告警风暴
        """
        self.threshold = alert_threshold
        self.sustained_seconds = sustained_seconds
        self.cool_down = cool_down_seconds
        self.above_threshold_since = None # 记录何时开始超过阈值
        self.last_alert_time = 0 # 记录上次告警时间
        self.lock = Lock()
        
        # 预热
        psutil.cpu_percent(interval=None)
        time.sleep(0.1)

    def check_and_alert(self, cpu_usage):
        """检查当前CPU使用率，并根据规则决定是否告警"""
        current_time = time.time()
        with self.lock:
            if cpu_usage >= self.threshold:
                if self.above_threshold_since is None:
                    # 第一次超过阈值，记录时间
                    self.above_threshold_since = current_time
                    print(f"[警告] CPU使用率({cpu_usage:.1f}%)超过阈值({self.threshold}%)，开始计时...")
                else:
                    # 持续超过阈值
                    duration = current_time - self.above_threshold_since
                    if duration >= self.sustained_seconds:
                        # 检查是否在冷却期内
                        if (current_time - self.last_alert_time) >= self.cool_down:
                            self._trigger_alert(cpu_usage, duration)
                            self.last_alert_time = current_time
                            # 触发告警后重置计时，等待下一次持续超标
                            self.above_threshold_since = current_time
            else:
                # 使用率低于阈值，重置状态
                if self.above_threshold_since is not None:
                    print(f"[恢复] CPU使用率({cpu_usage:.1f}%)已降至阈值以下。")
                    self.above_threshold_since = None

    def _trigger_alert(self, usage, duration):
        """触发告警的实际操作（这里模拟发送邮件）"""
        alert_msg = f"""
        【CPU使用率告警】
        时间: {time.strftime('%Y-%m-%d %H:%M:%S')}
        详情: CPU使用率已持续 {duration:.0f} 秒超过告警阈值！
        当前值: {usage:.1f}%
        阈值: {self.threshold}%
        请立即检查服务器状态。
        """
        print("="*50)
        print(alert_msg)
        print("="*50)
        # 在实际应用中，这里可以调用发送邮件的函数、发送HTTP请求到告警平台等。
        # self._send_email(alert_msg)

    def _send_email(self, content):
        """发送告警邮件的示例函数（需要配置SMTP）"""
        # 这里省略具体的邮件发送代码，可根据实际情况实现
        pass

    def run_monitoring(self, check_interval=5):
        """启动监控循环"""
        print(f"CPU告警代理已启动。阈值: {self.threshold}%， 持续: {self.sustained_seconds}秒， 冷却: {self.cool_down}秒")
        try:
            while True:
                cpu_usage = psutil.cpu_percent(interval=None)
                self.check_and_alert(cpu_usage)
                time.sleep(check_interval)
        except KeyboardInterrupt:
            print("\n告警监控已停止。")

# 使用示例：监控CPU，如果持续30秒超过80%就告警，告警后5分钟内不再重复告警
if __name__ == '__main__':
    alert_agent = CPUAlertAgent(alert_threshold=80.0, sustained_seconds=30, cool_down_seconds=300)
    alert_agent.run_monitoring(check_interval=5)

这个告警代理引入了两个关键概念：持续时长和冷却时间。这避免了因为CPU瞬间飙升（比如一个临时任务）就狂发告警，也防止了在问题持续期间告警信息刷屏。你可以根据业务敏感程度调整这些参数。告警方式也可以从简单的打印，扩展到邮件、短信、钉钉/企业微信机器人、或者对接Prometheus Alertmanager等专业告警系统。

4.3 可视化与集成：Grafana面板示例

数据收集了，告警也有了，最后一步是让人能直观地看到。这里我给出一个如何将我们收集的日志数据（假设推入了InfluxDB）在Grafana中配置成监控面板的思路。

首先，确保你的数据已经以某种格式写入了数据库。假设我们每条数据记录包含以下字段：

• measurement: cpu_metrics
• tags: host=server01
• fields: cpu_total_percent=12.5, cpu_core0_percent=10.1, cpu_core1_percent=15.0, ...
• time: 时间戳

那么，在Grafana中创建一个新面板，数据源选择你的时序数据库（如InfluxDB）。在查询编辑器里，你可以这样写：

查询A（总体CPU使用率折线图）:

SELECT mean("cpu_total_percent") FROM "cpu_metrics" WHERE $timeFilter GROUP BY time($__interval), "host" fill(null)

这个查询会生成所有主机总体CPU使用率随时间变化的曲线。

查询B（每个核心CPU使用率堆叠面积图）: 对于多核CPU，你可以为每个核心单独创建一个查询，或者使用支持多字段的函数。一个更高级的做法是，将每个核心的数据作为单独的序列查询出来，然后使用Grafana的“堆叠”和“分组”功能。

-- 查询核心0
SELECT mean("cpu_core0_percent") FROM "cpu_metrics" WHERE $timeFilter GROUP BY time($__interval) fill(null)
-- 查询核心1
SELECT mean("cpu_core1_percent") FROM "cpu_metrics" WHERE $timeFilter GROUP BY time($__interval) fill(null)
-- ... 以此类推

然后将这些查询的图例格式设置为Core {{index}}，并选择“堆叠”视图，就能直观地看到每个核心的贡献以及总和的趋势。

面板设置建议：

• 图例模式：设为 Table，可以清晰看到每个系列的最新值、最小值、最大值、平均值。
• 阈值：在可视化设置里，添加一条在80%处的红色阈值线，这样一眼就能看到什么时候触发了告警条件。
• 单位：Y轴单位设为 percent (0-100)。
• 刷新频率：根据你的采集间隔，设置合适的自动刷新频率（如5s、10s）。

这样一来，一个实时、直观的CPU监控面板就搭建好了。结合我们前面写的收集器和告警代理，你就拥有了一套从数据采集、异常告警到可视化展示的完整CPU监控解决方案。这套方案轻量、灵活，可以根据你的业务需求进行裁剪和扩展，无论是用于单台开发机，还是成百上千台服务器的集群，其核心思想都是相通的。