QC++ / Qt 学习之路

案例:系统资源监控面板

采集 CPU/内存与进程数据,后台线程取样 + QPainter 自绘折线图

实战第 46 / 48 章第六篇 · 案例实战

#这个案例做什么

写一个轻量的系统监控面板:上半部分是自绘的折线图,CPU 与内存两条曲线每秒向左推进一格,带网格、坐标刻度、图例和最新数值;下半部分是进程列表,按 CPU 占用从高到低排列,显示 PID、进程名、CPU 百分比和常驻内存,双击可以结束进程。所有采集工作都在后台线程里完成,界面拖着窗口、滚动列表时曲线依然流畅。这个案例回答一个很实际的问题:定时、耗 IO 的采集任务,怎么放进 Qt 应用而不卡界面。

系统资源监控 · QTimer + QChart 文件 视图 进程 帮助 开始监控 暂停 刷新 导出 CPU 使用率 62% 内存占用 7.8/16 GB 磁盘空间 45% 100% 0% 0s 60s CPU 内存 PID 进程名 CPU 内存 12.4% 8.1% 3.6% 1.2% 1024 2318 4412 6680 QtCreator cl.exe node python3 812 MB 456 MB 224 MB 96 MB 采样间隔 1 s · 更新于 12:04:31 QTimer 驱动 QProgressBar QChartView QTableWidget
监控面板界面结构——上方自绘折线图 + 下方进程表格 + 顶部图例

功能清单:

  • CPU 使用率:从 /proc/stat 取两次快照做差分,得到真实的瞬时占用率;
  • 内存占用:解析 /proc/meminfo,用 MemAvailable 计算已用量与百分比;
  • 进程列表:扫描 /proc/<pid>/stat,算出每个进程的 CPU 与 RSS 内存,按 CPU 排序;
  • 自绘折线图:网格 + 坐标轴 + 图例 + 两条曲线,支持暂停/继续与清空历史;
  • 后台采集:QObject 工作对象 + moveToThread,采集在子线程、刷新在主线程;
  • 结束进程:kill(pid, SIGTERM),失败时提示权限不足;
  • 窗口几何与采集间隔保存到 QSettings。

#用到的知识点

知识点出处
QObject + moveToThread 的线程用法第四篇第 8 章 多线程编程
跨线程信号槽与 qRegisterMetaType第四篇第 8 章 多线程编程 / 第三篇第 3 章
QPainter 自绘控件、抗锯齿、坐标映射第四篇第 5 章 绘图系统 QPainter
QTimer 定时触发第三篇第 6 章 常用基础控件
QTableWidget / QTableWidgetItem第三篇第 6 章 常用基础控件
布局管理与 QMainWindow第三篇第 7、8 章
QFile / QDir 遍历与文本解析第四篇第 6 章 文件与数据持久化
QSplitter 与 QHeaderView 拉伸策略第三篇第 7 章 布局管理
QSettings 持久化第四篇第 6 章 文件与数据持久化
隐式共享容器 QVector / QHash第三篇第 5 章 Qt 核心数据类型

#项目结构

Text
sysmon/
├── CMakeLists.txt
└── src/
    ├── main.cpp
    ├── sysinfo.h            # Sample / ProcInfo 数据结构
    ├── collector.h
    ├── collector.cpp        # 在子线程里读 /proc 的采集器
    ├── plotwidget.h
    ├── plotwidget.cpp       # 自绘折线图控件
    ├── mainwindow.h
    └── mainwindow.cpp       # 组装界面、接收采样、进程表格

层次非常清晰:Collector 不认识任何控件,只管吐出 Sample;PlotWidget 不认识 /proc,只管拿到数值画折线;MainWindow 把两者接起来。三者没有任何双向依赖,把采集器换成读 Windows PDH 或 macOS host_processor_info 的实现,界面代码一个字都不用改。

CMake
cmake_minimum_required(VERSION 3.16)

project(SysMon LANGUAGES CXX)

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_AUTOMOC ON)

find_package(Qt6 REQUIRED COMPONENTS Widgets)

qt_add_executable(SysMon
    src/main.cpp
    src/collector.cpp
    src/collector.h
    src/plotwidget.cpp
    src/plotwidget.h
    src/mainwindow.cpp
    src/mainwindow.h
    src/sysinfo.h
)

target_link_libraries(SysMon PRIVATE Qt6::Widgets)

if(MSVC)
    target_compile_options(SysMon PRIVATE /utf-8)
endif()

#核心实现

#数据采集:/proc 是"计数器"不是"百分比"

Linux 的 /proc/stat 第一行给出的是自开机以来累计的节拍数:

Text
cpu  123456 789 45678 9876543 23456 0 1234 0 0 0
     user   nice system  idle  iowait ...

里面没有任何百分比。要得到当前的 CPU 占用率,必须取两次快照做差分:占用率 = 1 - 空闲增量 / 总增量。这是所有监控系统(包括 top、htop、Prometheus node_exporter)的通用算法,也是新手最容易想当然做错的地方——只看一次快照永远只能得到"开机以来的平均值"。

内存同理:不能拿 MemFree 当可用内存,因为 Linux 会拿空闲内存做页缓存。正确的可用量是 MemAvailable(旧内核没有这个字段时退化为 MemFree + Buffers + Cached)。

进程 CPU 占用同样要差分:记下上一轮的 utime + stime,除以采样间隔再除以 sysconf(_SC_CLK_TCK)(通常是 100),得到这一秒里该进程消耗的 CPU 核数,乘 100 就是百分比——所以多核机器上单个进程的 CPU 可以超过 100%。

C++
// src/sysinfo.h
#pragma once

#include <QMetaType>
#include <QString>
#include <QVector>

struct ProcInfo
{
    int     pid   = 0;
    QString name;
    double  cpu   = 0.0;    // 百分比,多核下可能 > 100
    qint64  rssKb = 0;      // 常驻内存,KB
};

struct Sample
{
    double  cpu        = 0.0;   // 整机 CPU 百分比 0~100
    double  mem        = 0.0;   // 内存百分比 0~100
    qint64  memTotalKb = 0;
    qint64  memUsedKb  = 0;
    QVector<ProcInfo> procs;
};

// 跨线程信号槽必须注册自定义类型,否则连接会失败并输出运行时警告
Q_DECLARE_METATYPE(Sample)
Q_DECLARE_METATYPE(QVector<ProcInfo>)
C++
// src/collector.h
#pragma once

#include <QHash>
#include <QObject>

#include "sysinfo.h"

class Collector : public QObject
{
    Q_OBJECT
public:
    explicit Collector(QObject *parent = nullptr);

    void setInterval(int ms) { m_intervalMs = ms; }

public slots:
    // 在子线程里被调用,内部持有自己的 QTimer
    void start();
    void stop();

signals:
    void sampleReady(const Sample &sample);

private slots:
    void collect();

private:
    Sample readSample();      // 会更新内部的前一次快照,故非 const

    int    m_intervalMs = 1000;
    qint64 m_prevTotal  = 0;
    qint64 m_prevIdle   = 0;
    double m_clkTck     = 100.0;
    QHash<int, qint64> m_prevProcTicks;   // pid -> 上一轮的 utime+stime
};
C++
// src/collector.cpp
#include "collector.h"

#include <cctype>
#include <cstring>

#include <QByteArray>
#include <QDir>
#include <QFile>
#include <QTimer>

#ifdef Q_OS_LINUX
#include <unistd.h>
#endif

namespace {

QByteArray readFile(const QString &path)
{
    QFile f(path);
    // 进程可能刚好退出,读失败是常态,返回空串即可
    if (!f.open(QIODevice::ReadOnly)) return {};
    return f.readAll();
}

qint64 memValueKb(const QByteArray &text, const char *key)
{
    const int idx = text.indexOf(key);
    if (idx < 0) return -1;

    int p = idx + int(strlen(key));
    while (p < text.size() && !isdigit(static_cast<unsigned char>(text.at(p)))) ++p;
    int e = p;
    while (e < text.size() && isdigit(static_cast<unsigned char>(text.at(e)))) ++e;

    bool ok = false;
    const qint64 v = text.mid(p, e - p).toLongLong(&ok);
    return ok ? v : -1;
}

} // namespace

Collector::Collector(QObject *parent) : QObject(parent)
{
#ifdef Q_OS_LINUX
    m_clkTck = double(sysconf(_SC_CLK_TCK));
    if (m_clkTck <= 0) m_clkTck = 100.0;
#endif
}

void Collector::start()
{
    // 关键:这个 QTimer 在 start() 里创建,而 start() 运行在子线程中,
    // 所以定时器的回调也会在子线程里执行
    auto *timer = new QTimer(this);
    timer->setInterval(m_intervalMs);
    connect(timer, &QTimer::timeout, this, &Collector::collect);
    timer->start();
    collect();   // 立刻采一次,避免启动时图表空着
}

void Collector::stop()
{
    if (auto *t = findChild<QTimer *>()) t->stop();
}

void Collector::collect()
{
    const Sample sample = readSample();
    emit sampleReady(sample);
}

#ifdef Q_OS_LINUX

Sample Collector::readSample()
{
    Sample s;

    // ---- CPU:两次快照差分 ----
    const QByteArray stat = readFile(QStringLiteral("/proc/stat"));
    const QByteArrayList fields = stat.left(stat.indexOf('\n')).simplified().split(' ');
    if (fields.size() >= 9 && fields.first() == "cpu") {
        qint64 total = 0;
        for (int i = 1; i < fields.size(); ++i)
            total += fields.at(i).toLongLong();

        const qint64 idle = fields.at(4).toLongLong()   // idle
                          + fields.at(5).toLongLong();  // iowait

        if (m_prevTotal > 0) {
            const qint64 dTotal = total - m_prevTotal;
            const qint64 dIdle  = idle  - m_prevIdle;
            if (dTotal > 0)
                s.cpu = 100.0 * (1.0 - double(dIdle) / double(dTotal));
        }
        m_prevTotal = total;
        m_prevIdle  = idle;
    }

    // ---- 内存:可用量要用 MemAvailable ----
    const QByteArray meminfo = readFile(QStringLiteral("/proc/meminfo"));
    const qint64 totalKb = memValueKb(meminfo, "MemTotal:");
    qint64 availKb = memValueKb(meminfo, "MemAvailable:");
    if (availKb < 0)
        availKb = memValueKb(meminfo, "MemFree:")
                + memValueKb(meminfo, "Buffers:")
                + memValueKb(meminfo, "Cached:");

    if (totalKb > 0 && availKb >= 0) {
        s.memTotalKb = totalKb;
        s.memUsedKb  = totalKb - availKb;
        s.mem        = 100.0 * double(s.memUsedKb) / double(totalKb);
    }

    // ---- 进程列表 ----
    const double intervalSec = double(m_intervalMs) / 1000.0;
    QHash<int, qint64> current;

    const QStringList dirs = QDir(QStringLiteral("/proc")).entryList(
        QDir::Dirs | QDir::NoDotAndDotDot);

    for (const QString &entry : dirs) {
        bool isPid = false;
        const int pid = entry.toInt(&isPid);
        if (!isPid) continue;                  // 跳过 sys、net 等非数字目录

        const QByteArray data =
            readFile(QStringLiteral("/proc/%1/stat").arg(entry));
        if (data.isEmpty()) continue;

        const int rb = data.indexOf(')');
        if (rb < 0) continue;
        const int lb = data.indexOf('(');

        ProcInfo p;
        p.pid  = pid;
        p.name = QString::fromLocal8Bit(data.mid(lb + 1, rb - lb - 1));

        // ')' 之后:state(3) ppid(4) ... utime(14) stime(15) ... rss(24)
        const QByteArrayList rest = data.mid(rb + 2).simplified().split(' ');
        if (rest.size() < 22) continue;

        const qint64 utime = rest.at(11).toLongLong();
        const qint64 stime = rest.at(12).toLongLong();
        const qint64 ticks = utime + stime;
        current.insert(pid, ticks);

        // 页面数 × 4KB = 常驻内存
        p.rssKb = rest.at(21).toLongLong() * 4;

        const qint64 prev = m_prevProcTicks.value(pid, -1);
        if (prev >= 0 && intervalSec > 0) {
            const double used = double(ticks - prev) / m_clkTck;   // 消耗的 CPU 秒数
            p.cpu = 100.0 * used / intervalSec;
        }
        s.procs.append(p);
    }

    m_prevProcTicks = current;

    // 按 CPU 占用降序,只保留前 200 条,避免表格过长
    std::sort(s.procs.begin(), s.procs.end(),
              [](const ProcInfo &a, const ProcInfo &b) { return a.cpu > b.cpu; });
    if (s.procs.size() > 200)
        s.procs.resize(200);

    return s;
}

#else

// 非 Linux 平台:留空实现,保证可以编译。
// Windows 可用 PDH(PdhOpenQuery + PdhCollectQueryData)或 GetSystemTimes;
// macOS 可用 host_processor_info + mach_task_basic_info,算法与上面完全一致。
Sample Collector::readSample()
{
    return Sample{};
}

#endif

#后台线程:绝不给 QThread 子类化

采集要用子线程,但不要继承 QThread 并重写 run(),那是把整个对象搬到子线程、容易在线程上下文上出错的老做法。正确姿势是"工作对象 + moveToThread":

  1. Collector 是无父对象的普通 QObject;
  2. collector->moveToThread(thread) 后,它的槽函数全部在子线程执行;
  3. 它在 start() 槽里创建的 QTimer 属于子线程,回调也在子线程;
  4. 它 emit 的信号通过队列连接跨线程传回主线程,主线程里更新界面是安全的。

这个模式还有个额外好处:QThread 本身可以继续用来管理生命周期,finished 信号触发 deleteLater 即可,不会泄漏。

C++
// src/mainwindow.cpp(线程装配部分)
void MainWindow::startCollecting()
{
    m_thread = new QThread(this);
    m_collector = new Collector;          // 不能有 parent,否则无法 moveToThread
    m_collector->setInterval(m_intervalMs);
    m_collector->moveToThread(m_thread);

    // 线程退出时销毁工作对象,顺序不能反
    connect(m_thread, &QThread::finished, m_collector, &QObject::deleteLater);
    // started 信号是在新线程里发出的,所以 start() 跑在子线程
    connect(m_thread, &QThread::started, m_collector, &Collector::start);
    // 跨线程自动使用队列连接,sampleReady 的处理在主线程
    connect(m_collector, &Collector::sampleReady,
            this, &MainWindow::onSample);

    m_thread->start();
}

void MainWindow::onSample(const Sample &sample)
{
    // 这个函数一定运行在主线程,可以安全操作控件
    m_plot->append(QStringLiteral("CPU"), sample.cpu);
    m_plot->append(QStringLiteral("内存"), sample.mem);

    m_memLabel->setText(QStringLiteral("内存 %1 / %2 MB")
                            .arg(sample.memUsedKb / 1024)
                            .arg(sample.memTotalKb / 1024));

    updateProcessTable(sample.procs);
}

MainWindow::~MainWindow()
{
    // 退出流程:停止采集 → 退出事件循环 → 等线程真正结束
    if (m_thread) {
        QMetaObject::invokeMethod(m_collector, &Collector::stop, Qt::QueuedConnection);
        m_thread->quit();
        m_thread->wait(3000);
    }
}

#自绘折线图:环形缓冲 + 坐标映射

折线图的核心是数据点数量固定:每来一个采样就 append,超过 m_maxPoints 就丢掉最老的一个,这样曲线永远不会画出界,也不用做滚动变换。用 QVector<double> 当环形缓冲,为了简单这里直接用 removeFirst()——90 个元素的移动成本可以忽略。

绘制分四层:背景 → 网格与刻度 → 曲线 → 图例。坐标映射是唯一需要算的地方:

Text
x = padding + i / (maxPoints - 1) * plotWidth
y = plotTop + (1 - value / 100) * plotHeight

注意 QPainter 的 y 轴向下,所以要用 (1 - v/100) 而不是 v/100。曲线用 drawPolyline 一次画完,比逐段 drawLine 快得多,配合 Antialiasing 才不会锯齿。

C++
// src/plotwidget.h
#pragma once

#include <QColor>
#include <QString>
#include <QVector>
#include <QWidget>

class PlotWidget : public QWidget
{
    Q_OBJECT
public:
    explicit PlotWidget(QWidget *parent = nullptr);

    void addSeries(const QString &name, const QColor &color);
    void append(const QString &name, double value);
    void clear();
    void setMaxPoints(int n);
    void setPaused(bool paused) { m_paused = paused; update(); }

protected:
    void paintEvent(QPaintEvent *event) override;

private:
    struct Series
    {
        QString        name;
        QColor         color;
        QVector<double> data;
    };

    QRect  plotRect() const;
    QPointF toPoint(int index, int count, double value, const QRect &r) const;

    QVector<Series> m_series;
    int   m_maxPoints = 90;
    bool  m_paused    = false;
};
C++
// src/plotwidget.cpp
#include "plotwidget.h"

#include <QPainter>
#include <QPen>

namespace {
constexpr int kPadding = 34;   // 留出左侧刻度与底部文字的空间
}

PlotWidget::PlotWidget(QWidget *parent) : QWidget(parent)
{
    setMinimumHeight(180);
    // 自绘控件要自己铺满背景,否则窗口合成时会有一次额外擦除
    setAttribute(Qt::WA_OpaquePaintEvent);
}

void PlotWidget::addSeries(const QString &name, const QColor &color)
{
    m_series.append({ name, color, {} });
}

void PlotWidget::setMaxPoints(int n) { m_maxPoints = qMax(10, n); }

void PlotWidget::clear()
{
    for (Series &s : m_series) s.data.clear();
    update();
}

void PlotWidget::append(const QString &name, double value)
{
    for (Series &s : m_series) {
        if (s.name != name) continue;
        s.data.append(qBound(0.0, value, 100.0));
        while (s.data.size() > m_maxPoints)
            s.data.removeFirst();          // 丢掉最老的点,形成向左滚动的效果
    }
    if (!m_paused)
        update();
}

QRect PlotWidget::plotRect() const
{
    return rect().adjusted(kPadding, 10, -10, -kPadding + 10);
}

QPointF PlotWidget::toPoint(int index, int count, double value, const QRect &r) const
{
    const double x = count > 1
        ? r.left() + double(index) / double(count - 1) * r.width()
        : r.left();
    // y 轴向下,所以要用 1 - v/100 翻转
    const double y = r.bottom() - (value / 100.0) * r.height();
    return QPointF(x, y);
}

void PlotWidget::paintEvent(QPaintEvent *)
{
    QPainter p(this);
    p.setRenderHint(QPainter::Antialiasing, true);

    p.fillRect(rect(), QColor(24, 26, 31));
    const QRect r = plotRect();

    // ---- 1. 网格与坐标轴 ----
    p.setPen(QPen(QColor(60, 64, 74), 1));
    p.setBrush(Qt::NoBrush);
    p.drawRect(r);

    QPen grid(QColor(46, 50, 58), 1, Qt::DotLine);
    p.setPen(grid);
    for (int i = 1; i < 4; ++i) {
        const int y = r.top() + i * r.height() / 4;
        p.drawLine(r.left(), y, r.right(), y);
    }
    for (int i = 1; i < 6; ++i) {
        const int x = r.left() + i * r.width() / 6;
        p.drawLine(x, r.top(), x, r.bottom());
    }

    p.setPen(QColor(130, 136, 148));
    for (int i = 0; i <= 4; ++i) {
        const int value = 100 - i * 25;
        const int y = r.top() + i * r.height() / 4;
        p.drawText(QRect(0, y - 7, kPadding - 6, 14),
                   Qt::AlignRight | Qt::AlignVCenter, QString::number(value));
    }

    // ---- 2. 曲线 ----
    p.setClipRect(r);                 // 曲线抖动时不会画到坐标轴外面
    for (const Series &s : std::as_const(m_series)) {
        if (s.data.isEmpty()) continue;

        QPolygonF polyline;
        for (int i = 0; i < s.data.size(); ++i)
            polyline << toPoint(i, m_maxPoints, s.data.at(i), r);

        p.setPen(QPen(s.color, 2.0, Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin));
        p.setBrush(Qt::NoBrush);
        p.drawPolyline(polyline);

        // 最新一点画个实心圆,视觉上能一眼看到"当前值"
        p.setBrush(s.color);
        p.setPen(Qt::NoPen);
        p.drawEllipse(polyline.last(), 3.0, 3.0);
    }
    p.setClipping(false);

    // ---- 3. 图例 ----
    int x = r.left() + 4;
    const int legendY = height() - 18;
    for (const Series &s : std::as_const(m_series)) {
        p.setPen(Qt::NoPen);
        p.setBrush(s.color);
        p.drawRoundedRect(x, legendY + 4, 10, 8, 2, 2);

        p.setPen(QColor(200, 205, 215));
        const QString text = s.data.isEmpty()
            ? QStringLiteral("%1 --").arg(s.name)
            : QStringLiteral("%1 %2%").arg(s.name)
                  .arg(s.data.last(), 0, 'f', 1);
        p.drawText(QRect(x + 15, legendY, 120, 20), Qt::AlignLeft | Qt::AlignVCenter, text);
        x += 15 + p.fontMetrics().horizontalAdvance(text) + 16;
    }
}

#主窗口:进程表格与批量刷新

进程表格每次采样都要整体替换内容。如果直接 setItem 逐格写,会触发大量重排与重绘。两个优化:一是 setUpdatesEnabled(false) 把整批更新包起来,最后一次性重绘;二是行号复用——行数一致时只改文本,不要每次 clear() 再重建,否则会导致选中行丢失、滚动条跳回顶部。

结束进程要慎用 SIGKILL,先发 SIGTERM 给进程自己收尾的机会;kill 返回 -1 且 errno == EPERM 说明是别人的进程,提示权限不足而不是静默失败。

C++
// src/mainwindow.cpp(界面与表格部分)
// 需要 #include <QHeaderView> <QLabel> <QMessageBox> <QSplitter> <QStatusBar>
//       <QTableWidget> <QTableWidgetItem>
// Linux 下还需要 #include <signal.h>(kill/SIGTERM)与 <cerrno>(errno/strerror)
void MainWindow::buildUi()
{
    m_plot = new PlotWidget(this);
    m_plot->addSeries(QStringLiteral("CPU"), QColor(86, 182, 194));
    m_plot->addSeries(QStringLiteral("内存"), QColor(204, 150, 88));

    m_table = new QTableWidget(this);
    m_table->setColumnCount(4);
    m_table->setHorizontalHeaderLabels(
        { QStringLiteral("PID"), QStringLiteral("进程"), QStringLiteral("CPU %"),
          QStringLiteral("内存 MB") });
    m_table->setSelectionBehavior(QAbstractItemView::SelectRows);
    m_table->setEditTriggers(QAbstractItemView::NoEditTriggers);
    m_table->verticalHeader()->setVisible(false);
    m_table->setAlternatingRowColors(true);

    auto *hh = m_table->horizontalHeader();
    hh->setSectionResizeMode(0, QHeaderView::ResizeToContents);
    hh->setSectionResizeMode(1, QHeaderView::Stretch);
    hh->setSectionResizeMode(2, QHeaderView::ResizeToContents);
    hh->setSectionResizeMode(3, QHeaderView::ResizeToContents);

    auto *splitter = new QSplitter(Qt::Vertical, this);
    splitter->addWidget(m_plot);
    splitter->addWidget(m_table);
    splitter->setStretchFactor(0, 1);
    splitter->setStretchFactor(1, 2);
    setCentralWidget(splitter);

    connect(m_table, &QTableWidget::itemDoubleClicked,
            this, [this](QTableWidgetItem *item) { killSelected(); });

    m_memLabel = new QLabel(this);
    statusBar()->addPermanentWidget(m_memLabel);
}

void MainWindow::updateProcessTable(const QVector<ProcInfo> &procs)
{
    m_table->setUpdatesEnabled(false);       // 批量更新期间不重绘

    // 行数不变时只改文本,避免重建导致选中与滚动位置丢失
    if (m_table->rowCount() != procs.size())
        m_table->setRowCount(procs.size());

    for (int i = 0; i < procs.size(); ++i) {
        const ProcInfo &p = procs.at(i);
        setCell(i, 0, QString::number(p.pid));
        setCell(i, 1, p.name);
        setCell(i, 2, QString::number(p.cpu, 'f', 1));
        setCell(i, 3, QString::number(p.rssKb / 1024));

        // 高 CPU 的进程标红,一眼能看到是谁在吃资源
        if (p.cpu > 50.0) {
            QTableWidgetItem *it = m_table->item(i, 2);
            if (it) it->setForeground(QColor(214, 80, 72));
        }
    }

    m_table->setUpdatesEnabled(true);
}

void MainWindow::setCell(int row, int col, const QString &text)
{
    QTableWidgetItem *it = m_table->item(row, col);
    if (!it) {
        it = new QTableWidgetItem(text);
        m_table->setItem(row, col, it);
        return;
    }
    if (it->text() != text)
        it->setText(text);
}

void MainWindow::killSelected()
{
    const int row = m_table->currentRow();
    if (row < 0) return;

    const int pid = m_table->item(row, 0)->text().toInt();
    const QString name = m_table->item(row, 1)->text();

    if (QMessageBox::question(this, QStringLiteral("结束进程"),
                              QStringLiteral("结束 %1(PID %2)?").arg(name).arg(pid))
        != QMessageBox::Yes) {
        return;
    }

#ifdef Q_OS_LINUX
    // 先礼貌地请求退出,失败再提示权限问题
    if (kill(pid_t(pid), SIGTERM) != 0)
        QMessageBox::warning(this, QStringLiteral("结束失败"),
                             QStringLiteral("无法结束 PID %1:%2")
                                 .arg(pid).arg(QString::fromLocal8Bit(strerror(errno))));
#else
    QMessageBox::information(this, QStringLiteral("不支持"),
                             QStringLiteral("本案例的结束进程仅实现 Linux 版本"));
#endif
}
C++
// src/main.cpp
#include <QApplication>
#include <QCoreApplication>

#include "mainwindow.h"
#include "sysinfo.h"

int main(int argc, char *argv[])
{
    QApplication app(argc, argv);
    QCoreApplication::setOrganizationName(QStringLiteral("QtTutorial"));
    QCoreApplication::setApplicationName(QStringLiteral("SysMon"));

    // 跨线程队列连接必须提前注册自定义类型,否则只会在运行时收到警告
    qRegisterMetaType<Sample>("Sample");
    qRegisterMetaType<QVector<ProcInfo>>("QVector<ProcInfo>");

    MainWindow w;
    w.show();
    return app.exec();
}

#关键细节与踩坑

1. CPU 占用率显示 0% 或恒定不变。 因为 /proc/stat 里是累计节拍,不是百分比。必须保存上一轮的 total 与 idle,用差分算:如果只采一次快照,第一次必然是 0(没有前值)。同理进程的 CPU 也要用 utime + stime 的差分除以采样间隔,所以采样间隔必须与实际时钟一致——代码里用的是 m_intervalMs,如果定时器被系统节流(比如窗口最小化)就会偏高。

2. 内存"已用 95%"其实是正常的。 拿 MemFree 当可用内存会把页缓存算成已用。Linux 的设计是"空闲内存就是浪费的内存",被缓存的部分随时可以回收,所以必须用 MemAvailable。这是写监控工具最常见的误解,很多早期工具都犯过。

3. 界面卡顿、曲线一顿一顿。 要么采集放主线程(读 /proc 上百个文件本身就是 IO 密集操作),要么主线程收到信号后又做了一堆计算。解决:采集器整体搬进子线程,主线程只负责 append + update()。另外别忘了 qRegisterMetaType——没注册时跨线程信号会连接失败,症状是"图表完全不动但也不报错",只有运行时警告输出。

4. 定时器不工作,或者报错"Timers cannot be started from another thread"。 QTimer 属于创建它的线程。如果 Collector 在构造函数里建 QTimer,那个定时器属于主线程,moveToThread 之后回调仍在主线程执行,采集就白搬到子线程了。必须在子线程里执行的槽(start())中创建定时器——这也解释了本案例为什么不在构造函数里建。

5. 表格闪烁、选中行丢失、滚动条跳位。 每 100 个进程 × 4 列的逐格更新会触发海量重绘。用 setUpdatesEnabled(false) 包起来,并且不要每次 clear() 重建,行数一致时复用 QTableWidgetItem 只改文本。想用箭头排序(setSortingEnabled(true))时更要小心:排序会在你插入数据时重排,必须暂时关掉。

6. 曲线画到坐标轴外面。 数据点刚 append 时可能出现极值抖动,或者直接画在 padding 区域上。用 p.setClipRect(plotRect()) 把曲线裁剪在绘图区内,画完 setClipping(false)。另外自绘控件记得 setAttribute(Qt::WA_OpaquePaintEvent) 并自己 fillRect,能省掉一次系统擦除。

7. 退出时崩溃或线程还活着。 析构顺序必须是"停止采集 → quit() → wait()"。QThread 还在运行时销毁对象,Qt 会打印 QThread: Destroyed while thread is still running。注意 wait(3000) 要有超时,否则子线程卡死会把整个退出流程卡住。

#还能怎么扩展

  • 网络与磁盘 IO:再解析 /proc/net/dev 与 /proc/diskstats,同样做差分得到 KB/s,多开两条曲线;PlotWidget 已经支持任意多条系列,加数据即可。
  • 多核 CPU:/proc/stat 里 cpu0、cpu1 各有独立行,为每个核开一条曲线,或者用 QStackedBar 风格的小方格矩阵(类似 htop)。
  • 跨平台采集:Windows 用 PDH(PdhOpenQuery + PdhAddCounter + PdhCollectQueryData)或 GetSystemTimes;macOS 用 host_processor_info 取 CPU_STATE_USER/SYSTEM/IDLE 之和做差分,mach_task_basic_info 取内存。算法与 Linux 版本完全一致,只换 readSample() 内部实现。
  • 悬浮提示与交互:给 PlotWidget 加鼠标移动事件,反算 x 坐标对应的采样索引,画出十字准线与数值气泡;再支持框选区间查看细节。
  • 历史记录与导出:把采样写进 SQLite(第四篇第 7 章)或直接追加 CSV,用 QTimer 每分钟落盘一次;配合 QChart(Qt Charts 模块)可以直接换成专业图表控件,自绘逻辑则能原样保留。

#小结

  • /proc 提供的是累计计数器,一切"瞬时值"都必须靠两次快照差分得到,包括整机 CPU、单进程 CPU、网络与磁盘速率。
  • 可用内存看 MemAvailable 而不是 MemFree;单进程 CPU 在多核上可以超过 100%。
  • 后台任务用"工作对象 + moveToThread",不要子类化 QThread 重写 run();定时器要在子线程里创建才能真正把回调搬到子线程;跨线程传自定义类型必须 qRegisterMetaType,否则连接静默失败——这是最隐蔽的坑。
  • 自绘图表用固定长度的环形缓冲(超出丢最老的点),坐标映射记得 y 轴向下要翻转,并用 setClipRect 防止画出界。
  • 表格批量刷新用 setUpdatesEnabled(false) 包裹,并且复用 QTableWidgetItem 而不是重建,才能既不闪烁又不丢选中。

#练习

  1. 加一条"负载均值"曲线:读取 /proc/loadavg 的前三个数(1/5/15 分钟),把 1 分钟负载按 load / CPU核心数 × 100 归一化后加入 PlotWidget,并在图例里显示原始值。
  2. 加网络速率:解析 /proc/net/dev 中指定网卡的 receive bytes 与 transmit bytes,差分后除以间隔得到 KB/s,addSeries 两条新曲线(注意单位换算与重启后的计数器归零)。
  3. 实现进程过滤:在表格上方加一个 QLineEdit,在 updateProcessTable 里跳过名字不包含关键字的进程;注意过滤后行数变化会走 setRowCount 分支,别让表格残留空行。
  4. 支持调整采集间隔:工具栏加一个 QSpinBox(200–5000 ms),修改时用 QMetaObject::invokeMethod(m_collector, "setInterval", Qt::QueuedConnection, Q_ARG(int, ms)) 跨线程设置,并同步修改定时器已启动的间隔。
我的学习笔记笔记总览
笔记保存在本机浏览器(localStorage),换设备或清理缓存会丢失;重要内容请点「导出全部笔记」存成 .md 文件。