案例:系统资源监控面板
采集 CPU/内存与进程数据,后台线程取样 + QPainter 自绘折线图
#这个案例做什么
写一个轻量的系统监控面板:上半部分是自绘的折线图,CPU 与内存两条曲线每秒向左推进一格,带网格、坐标刻度、图例和最新数值;下半部分是进程列表,按 CPU 占用从高到低排列,显示 PID、进程名、CPU 百分比和常驻内存,双击可以结束进程。所有采集工作都在后台线程里完成,界面拖着窗口、滚动列表时曲线依然流畅。这个案例回答一个很实际的问题:定时、耗 IO 的采集任务,怎么放进 Qt 应用而不卡界面。
功能清单:
- 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 核心数据类型 |
#项目结构
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_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 第一行给出的是自开机以来累计的节拍数:
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%。
// 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>)// 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
};// 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":
Collector是无父对象的普通QObject;collector->moveToThread(thread)后,它的槽函数全部在子线程执行;- 它在
start()槽里创建的QTimer属于子线程,回调也在子线程; - 它
emit的信号通过队列连接跨线程传回主线程,主线程里更新界面是安全的。
这个模式还有个额外好处:QThread 本身可以继续用来管理生命周期,finished 信号触发 deleteLater 即可,不会泄漏。
// 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 个元素的移动成本可以忽略。
绘制分四层:背景 → 网格与刻度 → 曲线 → 图例。坐标映射是唯一需要算的地方:
x = padding + i / (maxPoints - 1) * plotWidth
y = plotTop + (1 - value / 100) * plotHeight注意 QPainter 的 y 轴向下,所以要用 (1 - v/100) 而不是 v/100。曲线用 drawPolyline 一次画完,比逐段 drawLine 快得多,配合 Antialiasing 才不会锯齿。
// 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;
};// 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 说明是别人的进程,提示权限不足而不是静默失败。
// 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
}// 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而不是重建,才能既不闪烁又不丢选中。
#练习
- 加一条"负载均值"曲线:读取
/proc/loadavg的前三个数(1/5/15 分钟),把 1 分钟负载按load / CPU核心数 × 100归一化后加入PlotWidget,并在图例里显示原始值。 - 加网络速率:解析
/proc/net/dev中指定网卡的receive bytes与transmit bytes,差分后除以间隔得到 KB/s,addSeries两条新曲线(注意单位换算与重启后的计数器归零)。 - 实现进程过滤:在表格上方加一个
QLineEdit,在updateProcessTable里跳过名字不包含关键字的进程;注意过滤后行数变化会走setRowCount分支,别让表格残留空行。 - 支持调整采集间隔:工具栏加一个
QSpinBox(200–5000 ms),修改时用QMetaObject::invokeMethod(m_collector, "setInterval", Qt::QueuedConnection, Q_ARG(int, ms))跨线程设置,并同步修改定时器已启动的间隔。