Qt多线程编程的8个段位-洪萨配资

一个简单的文件处理功能，竟让整个界面卡死5秒——这种经历，你是否也熟悉？

作为Qt开发者，我们总在单线程的舒适区徘徊，直到性能问题狠狠打脸。今天，我将用实际踩坑换来的经验，带你彻底掌握Qt多线程的核心心法。不是枯燥的API文档翻译，而是能直接用到项目里的实战方案。

接下来的10分钟，你会看到：
✅ 从‘线程恐慌’到‘并行掌控’的思维转变
✅ 3种真实业务场景的多线程改造实录
✅ 一行代码就能避免的常见崩溃陷阱

如果你也曾：

在信号槽跨线程调用时一脸茫然
面对QThread文档却不知从何下手
担心多线程会让代码复杂度爆炸

一、基础概念体系

1.线程基础

进程与线程区别
并发vs并行
线程安全概念
竞态条件与数据竞争
死锁、活锁、饥饿

2.Qt线程模型

线程亲和性（Thread Affinity）
事件循环（Event Loop）
线程局部存储
对象树与线程关系
二、核心技术组件体系

1.线程管理类

// 核心类层次 QThread // 线程基础类 QRunnable // 可运行任务接口 QThreadPool // 线程池管理 QtConcurrent // 高级并发框架

2.同步机制

// 互斥锁系列 QMutex // 互斥锁 QMutexLocker // RAII锁管理（推荐） QReadWriteLock // 读写锁 QReadLocker / QWriteLocker // 其他同步原语 QSemaphore // 信号量 QWaitCondition // 条件变量 QAtomicInteger // 原子操作

3.线程间通信

// 信号槽连接类型 Qt::AutoConnection // 自动（默认） Qt::DirectConnection // 直接（同线程） Qt::QueuedConnection // 排队（跨线程） Qt::BlockingQueuedConnection // 阻塞排队 // 事件系统 QCoreApplication::postEvent() // 线程安全的事件投递

三、编程范式与模式体系

1.Worker-Controller模式

// Worker对象 + 控制线程 class Worker : public QObject { Q_OBJECT public slots: void process() { /* 耗时操作 */ } signals: void finished(); }; // Controller管理线程生命周期 QThread *thread = new QThread; Worker *worker = new Worker; worker->moveToThread(thread);

2.生产者-消费者模式

// 使用QWaitCondition class Buffer { QMutex mutex; QWaitCondition bufferNotEmpty; QWaitCondition bufferNotFull; QList<Data> buffer; int maxSize; void produce(Data data) { mutex.lock(); while(buffer.size() == maxSize) { bufferNotFull.wait(&mutex); } buffer.append(data); bufferNotEmpty.wakeAll(); mutex.unlock(); } };

3.Map-Reduce模式

// 使用QtConcurrent QList<int> numbers = {1, 2, 3, 4, 5}; QFuture<int> result = QtConcurrent::mappedReduced( numbers, [](int n) { return n * n; }, // Map函数 [](int &result, int value) { // Reduce函数 result += value; } );

4.线程池模式

// 任务分割与并行处理 class ParallelTask : public QRunnable { void run() override { // 处理数据块 } }; QList<QRunnable*> tasks; for(auto chunk : dataChunks) { tasks.append(new ProcessTask(chunk)); } QThreadPool::globalInstance()->start(tasks.takeFirst());

四、高级技术体系

1.异步编程

// QFuture + QFutureWatcher QFuture<QImage> future = QtConcurrent::run(loadImage, "file.png"); QFutureWatcher<QImage> *watcher = new QFutureWatcher<QImage>(); connect(watcher, &QFutureWatcher<QImage>::finished, this, &MyClass::handleImageLoaded); watcher->setFuture(future); // C++20协程适配（Qt6+） QCoro::Task<> asyncOperation() { auto data = co_await downloadDataAsync(); co_return processData(data); }

2.数据并行处理

// 并行算法 QVector<double> vector(1000); // 并行填充 QtConcurrent::blockingMap(vector, [](double &value) { value = expensiveComputation(); }); // 并行过滤 QVector<double> filtered = QtConcurrent::blockingFiltered( vector, [](double value) { return value > 0.5; });

3.GUI线程安全

// 主线程更新GUI void Worker::doWork() { QString result = longOperation(); // 安全更新GUI QMetaObject::invokeMethod(mainWindow, "updateUI", Qt::QueuedConnection, Q_ARG(QString, result)); } // 使用QTimer延迟执行 QTimer::singleShot(0, this, []() { // 在主线程执行的代码 });

五、调试与优化体系

1.线程调试技术

// 线程命名（Qt5.10+） thread->setObjectName("NetworkThread"); // 获取线程信息 qDebug() << "Current thread:" << QThread::currentThread(); qDebug() << "Thread affinity:" << object->thread(); // 死锁检测 // 使用QDeadlineTimer设置超时 QMutex mutex; if(!mutex.tryLock(1000)) { // 1秒超时 qWarning() << "Possible deadlock detected!"; }

2.性能优化

线程数量优化（CPU核心数相关）
避免锁竞争
无锁数据结构
线程局部缓存
任务窃取调度

3.内存管理

// 正确释放资源 // 1. 使用deleteLater worker->deleteLater(); thread->quit(); thread->wait(); // 2. QObject自动清理 QObject::connect(thread, &QThread::finished, worker, &QObject::deleteLater); QObject::connect(thread, &QThread::finished, thread, &QObject::deleteLater);

六、设计模式与最佳实践

1.架构设计

线程边界设计
数据流设计
错误处理策略
资源管理策略

2.代码规范

// 好的实践 class ThreadSafeSingleton { public: static ThreadSafeSingleton& instance() { static QMutex mutex; QMutexLocker locker(&mutex); static ThreadSafeSingleton instance; return instance; } private: ThreadSafeSingleton() = default; Q_DISABLE_COPY(ThreadSafeSingleton) };

3.测试策略

单元测试中的线程测试
竞态条件检测
压力测试
性能基准测试
七、Qt版本特性差异

八、Qt多线程工程实战案例

1.【工程项目】运行结果

1.1 Worker-Controller模式示例

1.2 生产者-消费者

1.3线程池

1.4QtConcurrent并发处理

2.【工程目录结构】

2.1工程目录结构

2.2工程项目架构

整体架构图

2.3核心特性

2.3.1Worker-Controller模式

- ✅ 正确的线程生命周期管理

- ✅ 信号槽跨线程通信

- ✅ 优雅的停止机制

- ✅ 实时进度更新

2.3.2生产者-消费者模式

- ✅ 多生产者/多消费者支持

- ✅ 可配置缓冲区大小

- ✅ 使用QMutex和QWaitCondition同步

- ✅ 实时缓冲区状态监控

2.3.3线程池模式

- ✅ 自动线程复用

- ✅ 任务队列管理

- ✅ 并发任务执行

- ✅ 实时任务进度跟踪

2.3.4QtConcurrent框架

- ✅ Map操作（并行转换）

- ✅ Filter操作（并行过滤）

- ✅ Reduce操作（并行聚合）

- ✅ 平滑的进度条更新

3.【工程项目】部分代码

3.1worker.h

#ifndef WORKER_H #define WORKER_H #include <QObject> #include <QMutex> #include <QAtomicInt> class Worker : public QObject { Q_OBJECT public: explicit Worker(QObject *parent = nullptr); ~Worker(); public slots: void doWork(); void stopWork(); signals: void progress(int value); void finished(const QString &result); void error(const QString &error); private: QAtomicInt m_stopRequested; QMutex m_mutex; int m_workDuration; // 模拟工作时间（秒） }; #endif // WORKER_H

3.2worker.cpp

#include "worker.h" #include <QThread> #include <QDebug> Worker::Worker(QObject *parent) : QObject(parent) , m_stopRequested(0) , m_workDuration(5) // 默认5秒 { } Worker::~Worker() { qDebug() << "Worker析构函数被调用，线程:" << QThread::currentThread(); } void Worker::doWork() { qDebug() << "Worker::doWork() 开始执行，线程:" << QThread::currentThread(); m_stopRequested = 0; // 模拟耗时工作 const int totalSteps = 100; const int stepDuration = m_workDuration * 1000 / totalSteps; // 毫秒 for (int i = 0; i <= totalSteps; ++i) { // 检查停止请求 if (m_stopRequested.loadAcquire()) { emit error("工作被用户中断"); return; } // 模拟工作 QThread::msleep(stepDuration); // 发送进度信号 emit progress(i); // 每10%输出一次日志 if (i % 10 == 0) { qDebug() << "Worker进度:" << i << "%"; } } // 完成工作 QString result = QString("工作完成！处理了 %1 个步骤，耗时约 %2 秒") .arg(totalSteps) .arg(m_workDuration); emit finished(result); qDebug() << "Worker::doWork() 执行完成"; } void Worker::stopWork() { qDebug() << "Worker::stopWork() 被调用"; m_stopRequested.storeRelease(1); }

3.3mainwindow.h

#ifndef MAINWINDOW_H #define MAINWINDOW_H #include <QMainWindow> #include <QWidget> #include <QVBoxLayout> #include <QHBoxLayout> #include <QGridLayout> #include <QPushButton> #include <QTextEdit> #include <QLabel> #include <QProgressBar> #include <QGroupBox> #include <QSpinBox> #include <QLineEdit> #include <QTimer> #include <QThread> #include <QListWidget> #include <QTabWidget> #include "worker.h" #include "producerconsumer.h" #include "threadpooltask.h" #include "concurrentexample.h" class MainWindow : public QMainWindow { Q_OBJECT public: explicit MainWindow(QWidget *parent = nullptr); ~MainWindow(); private slots: // Worker-Controller模式相关槽函数 void onWorkerStart(); void onWorkerStop(); void onWorkerProgress(int value); void onWorkerFinished(const QString &result); void onWorkerError(const QString &error); // 生产者-消费者模式相关槽函数 void onProducerConsumerStart(); void onProducerConsumerStop(); void onBufferStatusChanged(int size, int maxSize); void onItemProcessed(const QString &item); // 线程池相关槽函数 void onThreadPoolStart(); void onThreadPoolStop(); void onTaskCompleted(int taskId, const QString &result); void onAllTasksCompleted(); // QtConcurrent相关槽函数 void onConcurrentStart(); void onConcurrentStop(); void onConcurrentProgress(int value); void onConcurrentFinished(const QString &result); private: void setupUI(); void setupWorkerTab(); void setupProducerConsumerTab(); void setupThreadPoolTab(); void setupConcurrentTab(); void logMessage(const QString &message, const QString &tab = "General"); // UI组件 QTabWidget *m_tabWidget; // Worker-Controller Tab QWidget *m_workerTab; QPushButton *m_workerStartBtn; QPushButton *m_workerStopBtn; QProgressBar *m_workerProgressBar; QTextEdit *m_workerLog; QLabel *m_workerResultLabel; Worker *m_worker; QThread *m_workerThread; // 生产者-消费者 Tab QWidget *m_producerConsumerTab; QPushButton *m_pcStartBtn; QPushButton *m_pcStopBtn; QSpinBox *m_producerCountSpinBox; QSpinBox *m_consumerCountSpinBox; QSpinBox *m_bufferSizeSpinBox; QProgressBar *m_bufferProgressBar; QLabel *m_bufferStatusLabel; QTextEdit *m_pcLog; QListWidget *m_processedItemsList; ProducerConsumer *m_producerConsumer; // 线程池 Tab QWidget *m_threadPoolTab; QPushButton *m_threadPoolStartBtn; QPushButton *m_threadPoolStopBtn; QSpinBox *m_taskCountSpinBox; QProgressBar *m_threadPoolProgressBar; QLabel *m_threadPoolStatusLabel; QTextEdit *m_threadPoolLog; ThreadPoolTask *m_threadPoolManager; // QtConcurrent Tab QWidget *m_concurrentTab; QPushButton *m_concurrentStartBtn; QPushButton *m_concurrentStopBtn; QSpinBox *m_dataSizeSpinBox; QProgressBar *m_concurrentProgressBar; QLabel *m_concurrentResultLabel; QTextEdit *m_concurrentLog; ConcurrentExample *m_concurrentExample; // 通用日志 QTextEdit *m_generalLog; }; #endif // MAINWINDOW_H

3.4mainwindow.cpp

#include "mainwindow.h" #include <QDateTime> #include <QMessageBox> #include <QCoreApplication> MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent) , m_worker(nullptr) , m_workerThread(nullptr) , m_producerConsumer(nullptr) , m_threadPoolManager(nullptr) , m_concurrentExample(nullptr) { setupUI(); // 初始化Worker（不创建，等到需要时再创建） m_worker = nullptr; m_workerThread = nullptr; // 初始化生产者-消费者 m_producerConsumer = new ProducerConsumer(this); connect(m_producerConsumer, &ProducerConsumer::bufferStatusChanged, this, &MainWindow::onBufferStatusChanged); connect(m_producerConsumer, &ProducerConsumer::itemProcessed, this, &MainWindow::onItemProcessed); // 初始化线程池管理器 m_threadPoolManager = new ThreadPoolTask(this); connect(m_threadPoolManager, &ThreadPoolTask::taskCompleted, this, &MainWindow::onTaskCompleted); connect(m_threadPoolManager, &ThreadPoolTask::allTasksCompleted, this, &MainWindow::onAllTasksCompleted); connect(m_threadPoolManager, &ThreadPoolTask::progress, this, [this](int completed, int total) { m_threadPoolProgressBar->setMaximum(total); m_threadPoolProgressBar->setValue(completed); m_threadPoolStatusLabel->setText(QString("状态: 执行中 (%1/%2)").arg(completed).arg(total)); }); // 初始化QtConcurrent示例 m_concurrentExample = new ConcurrentExample(this); connect(m_concurrentExample, &ConcurrentExample::progress, this, &MainWindow::onConcurrentProgress); connect(m_concurrentExample, &ConcurrentExample::finished, this, &MainWindow::onConcurrentFinished); logMessage("应用程序初始化完成", "General"); } MainWindow::~MainWindow() { // 停止所有工作线程 if (m_worker && m_workerThread && m_workerThread->isRunning()) { m_worker->stopWork(); m_workerThread->quit(); m_workerThread->wait(3000); } // 清理Worker对象 if (m_worker) { m_worker->deleteLater(); m_worker = nullptr; } if (m_workerThread) { m_workerThread->deleteLater(); m_workerThread = nullptr; } if (m_producerConsumer) { m_producerConsumer->stop(); } if (m_threadPoolManager) { m_threadPoolManager->stopTasks(); } if (m_concurrentExample) { m_concurrentExample->stopProcessing(); } // 处理事件循环，确保deleteLater执行 QCoreApplication::processEvents(); } void MainWindow::setupUI() { setWindowTitle("Qt多线程编程技术--综合实战应用"); setMinimumSize(1000, 700); resize(1200, 800); // 创建中央部件 QWidget *centralWidget = new QWidget(this); setCentralWidget(centralWidget); // 创建主布局 QVBoxLayout *mainLayout = new QVBoxLayout(centralWidget); // 创建标签页 m_tabWidget = new QTabWidget(this); mainLayout->addWidget(m_tabWidget); // 设置各个标签页 setupWorkerTab(); setupProducerConsumerTab(); setupThreadPoolTab(); setupConcurrentTab(); // 添加通用日志区域 QGroupBox *logGroup = new QGroupBox("通用日志", this); QVBoxLayout *logLayout = new QVBoxLayout(logGroup); m_generalLog = new QTextEdit(this); m_generalLog->setReadOnly(true); m_generalLog->setMaximumHeight(150); logLayout->addWidget(m_generalLog); mainLayout->addWidget(logGroup); } void MainWindow::setupWorkerTab() { m_workerTab = new QWidget(this); QVBoxLayout *layout = new QVBoxLayout(m_workerTab); // 标题 QLabel *titleLabel = new QLabel("Worker-Controller模式示例", this); titleLabel->setStyleSheet("font-size: 14pt; font-weight: bold;"); layout->addWidget(titleLabel); // 控制按钮 QHBoxLayout *buttonLayout = new QHBoxLayout(); m_workerStartBtn = new QPushButton("开始工作", this); m_workerStopBtn = new QPushButton("停止工作", this); m_workerStopBtn->setEnabled(false); buttonLayout->addWidget(m_workerStartBtn); buttonLayout->addWidget(m_workerStopBtn); buttonLayout->addStretch(); layout->addLayout(buttonLayout); // 进度条 QLabel *progressLabel = new QLabel("工作进度:", this); layout->addWidget(progressLabel); m_workerProgressBar = new QProgressBar(this); m_workerProgressBar->setMinimum(0); m_workerProgressBar->setMaximum(100); m_workerProgressBar->setValue(0); layout->addWidget(m_workerProgressBar); // 结果显示 m_workerResultLabel = new QLabel("结果: 等待开始...", this); m_workerResultLabel->setStyleSheet("padding: 5px; background-color: #f0f0f0;"); layout->addWidget(m_workerResultLabel); // 日志区域 QLabel *logLabel = new QLabel("工作日志:", this); layout->addWidget(logLabel); m_workerLog = new QTextEdit(this); m_workerLog->setReadOnly(true); m_workerLog->setMaximumHeight(200); layout->addWidget(m_workerLog); layout->addStretch(); // 连接信号槽 connect(m_workerStartBtn, &QPushButton::clicked, this, &MainWindow::onWorkerStart); connect(m_workerStopBtn, &QPushButton::clicked, this, &MainWindow::onWorkerStop); m_tabWidget->addTab(m_workerTab, "Worker-Controller"); } void MainWindow::setupProducerConsumerTab() { m_producerConsumerTab = new QWidget(this); QVBoxLayout *layout = new QVBoxLayout(m_producerConsumerTab); // 标题 QLabel *titleLabel = new QLabel("生产者-消费者模式示例", this); titleLabel->setStyleSheet("font-size: 14pt; font-weight: bold;"); layout->addWidget(titleLabel); // 参数设置 QGroupBox *paramGroup = new QGroupBox("参数设置", this); QGridLayout *paramLayout = new QGridLayout(paramGroup); paramLayout->addWidget(new QLabel("生产者数量:", this), 0, 0); m_producerCountSpinBox = new QSpinBox(this); m_producerCountSpinBox->setMinimum(1); m_producerCountSpinBox->setMaximum(10); m_producerCountSpinBox->setValue(3); paramLayout->addWidget(m_producerCountSpinBox, 0, 1); paramLayout->addWidget(new QLabel("消费者数量:", this), 0, 2); m_consumerCountSpinBox = new QSpinBox(this); m_consumerCountSpinBox->setMinimum(1); m_consumerCountSpinBox->setMaximum(10); m_consumerCountSpinBox->setValue(2); paramLayout->addWidget(m_consumerCountSpinBox, 0, 3); paramLayout->addWidget(new QLabel("缓冲区大小:", this), 1, 0); m_bufferSizeSpinBox = new QSpinBox(this); m_bufferSizeSpinBox->setMinimum(5); m_bufferSizeSpinBox->setMaximum(100); m_bufferSizeSpinBox->setValue(10); paramLayout->addWidget(m_bufferSizeSpinBox, 1, 1); layout->addWidget(paramGroup); // 控制按钮 QHBoxLayout *buttonLayout = new QHBoxLayout(); m_pcStartBtn = new QPushButton("开始生产消费", this); m_pcStopBtn = new QPushButton("停止", this); m_pcStopBtn->setEnabled(false); buttonLayout->addWidget(m_pcStartBtn); buttonLayout->addWidget(m_pcStopBtn); buttonLayout->addStretch(); layout->addLayout(buttonLayout); // 缓冲区状态 m_bufferStatusLabel = new QLabel("缓冲区: 0/10", this); m_bufferStatusLabel->setStyleSheet("padding: 5px; background-color: #e0e0e0;"); layout->addWidget(m_bufferStatusLabel); m_bufferProgressBar = new QProgressBar(this); m_bufferProgressBar->setMinimum(0); m_bufferProgressBar->setMaximum(100); m_bufferProgressBar->setValue(0); layout->addWidget(m_bufferProgressBar); // 日志和已处理项 QHBoxLayout *contentLayout = new QHBoxLayout(); // 日志 QVBoxLayout *logLayout = new QVBoxLayout(); logLayout->addWidget(new QLabel("运行日志:", this)); m_pcLog = new QTextEdit(this); m_pcLog->setReadOnly(true); logLayout->addWidget(m_pcLog); contentLayout->addLayout(logLayout, 1); // 已处理项列表 QVBoxLayout *listLayout = new QVBoxLayout(); listLayout->addWidget(new QLabel("已处理项:", this)); m_processedItemsList = new QListWidget(this); listLayout->addWidget(m_processedItemsList); contentLayout->addLayout(listLayout, 1); layout->addLayout(contentLayout); // 连接信号槽 connect(m_pcStartBtn, &QPushButton::clicked, this, &MainWindow::onProducerConsumerStart); connect(m_pcStopBtn, &QPushButton::clicked, this, &MainWindow::onProducerConsumerStop); m_tabWidget->addTab(m_producerConsumerTab, "生产者-消费者"); } void MainWindow::setupThreadPoolTab() { m_threadPoolTab = new QWidget(this); QVBoxLayout *layout = new QVBoxLayout(m_threadPoolTab); // 标题 QLabel *titleLabel = new QLabel("线程池模式示例", this); titleLabel->setStyleSheet("font-size: 14pt; font-weight: bold;"); layout->addWidget(titleLabel); // 参数设置 QHBoxLayout *paramLayout = new QHBoxLayout(); paramLayout->addWidget(new QLabel("任务数量:", this)); m_taskCountSpinBox = new QSpinBox(this); m_taskCountSpinBox->setMinimum(1); m_taskCountSpinBox->setMaximum(100); m_taskCountSpinBox->setValue(20); paramLayout->addWidget(m_taskCountSpinBox); paramLayout->addStretch(); layout->addLayout(paramLayout); // 控制按钮 QHBoxLayout *buttonLayout = new QHBoxLayout(); m_threadPoolStartBtn = new QPushButton("开始执行任务", this); m_threadPoolStopBtn = new QPushButton("停止任务", this); m_threadPoolStopBtn->setEnabled(false); buttonLayout->addWidget(m_threadPoolStartBtn); buttonLayout->addWidget(m_threadPoolStopBtn); buttonLayout->addStretch(); layout->addLayout(buttonLayout); // 状态和进度 m_threadPoolStatusLabel = new QLabel("状态: 等待开始...", this); m_threadPoolStatusLabel->setStyleSheet("padding: 5px; background-color: #f0f0f0;"); layout->addWidget(m_threadPoolStatusLabel); m_threadPoolProgressBar = new QProgressBar(this); m_threadPoolProgressBar->setMinimum(0); m_threadPoolProgressBar->setMaximum(100); m_threadPoolProgressBar->setValue(0); layout->addWidget(m_threadPoolProgressBar); // 日志 QLabel *logLabel = new QLabel("执行日志:", this); layout->addWidget(logLabel); m_threadPoolLog = new QTextEdit(this); m_threadPoolLog->setReadOnly(true); layout->addWidget(m_threadPoolLog); // 连接信号槽 connect(m_threadPoolStartBtn, &QPushButton::clicked, this, &MainWindow::onThreadPoolStart); connect(m_threadPoolStopBtn, &QPushButton::clicked, this, &MainWindow::onThreadPoolStop); m_tabWidget->addTab(m_threadPoolTab, "线程池"); } void MainWindow::setupConcurrentTab() { m_concurrentTab = new QWidget(this); QVBoxLayout *layout = new QVBoxLayout(m_concurrentTab); // 标题 QLabel *titleLabel = new QLabel("QtConcurrent框架示例", this); titleLabel->setStyleSheet("font-size: 14pt; font-weight: bold;"); layout->addWidget(titleLabel); // 参数设置 QHBoxLayout *paramLayout = new QHBoxLayout(); paramLayout->addWidget(new QLabel("数据大小:", this)); m_dataSizeSpinBox = new QSpinBox(this); m_dataSizeSpinBox->setMinimum(100); m_dataSizeSpinBox->setMaximum(1000000); m_dataSizeSpinBox->setValue(10000); paramLayout->addWidget(m_dataSizeSpinBox); paramLayout->addStretch(); layout->addLayout(paramLayout); // 控制按钮 QHBoxLayout *buttonLayout = new QHBoxLayout(); m_concurrentStartBtn = new QPushButton("开始并发处理", this); m_concurrentStopBtn = new QPushButton("停止处理", this); m_concurrentStopBtn->setEnabled(false); buttonLayout->addWidget(m_concurrentStartBtn); buttonLayout->addWidget(m_concurrentStopBtn); buttonLayout->addStretch(); layout->addLayout(buttonLayout); // 进度条 QLabel *progressLabel = new QLabel("处理进度:", this); layout->addWidget(progressLabel); m_concurrentProgressBar = new QProgressBar(this); m_concurrentProgressBar->setMinimum(0); m_concurrentProgressBar->setMaximum(100); m_concurrentProgressBar->setValue(0); layout->addWidget(m_concurrentProgressBar); // 结果显示 m_concurrentResultLabel = new QLabel("结果: 等待开始...", this); m_concurrentResultLabel->setStyleSheet("padding: 5px; background-color: #f0f0f0;"); layout->addWidget(m_concurrentResultLabel); // 日志 QLabel *logLabel = new QLabel("处理日志:", this); layout->addWidget(logLabel); m_concurrentLog = new QTextEdit(this); m_concurrentLog->setReadOnly(true); layout->addWidget(m_concurrentLog); // 连接信号槽 connect(m_concurrentStartBtn, &QPushButton::clicked, this, &MainWindow::onConcurrentStart); connect(m_concurrentStopBtn, &QPushButton::clicked, this, &MainWindow::onConcurrentStop); m_tabWidget->addTab(m_concurrentTab, "QtConcurrent"); } void MainWindow::logMessage(const QString &message, const QString &tab) { QString timestamp = QDateTime::currentDateTime().toString("hh:mm:ss.zzz"); QString logEntry = QString("[%1] %2").arg(timestamp, message); if (tab == "Worker") { m_workerLog->append(logEntry); } else if (tab == "ProducerConsumer") { m_pcLog->append(logEntry); } else if (tab == "ThreadPool") { m_threadPoolLog->append(logEntry); } else if (tab == "Concurrent") { m_concurrentLog->append(logEntry); } else { m_generalLog->append(logEntry); } } // Worker-Controller模式槽函数实现 void MainWindow::onWorkerStart() { // 检查是否正在运行 if (m_workerThread && m_workerThread->isRunning()) { logMessage("工作线程已在运行中", "Worker"); return; } // 如果之前的线程还在清理，等待它完成 if (m_workerThread) { if (m_workerThread->isRunning()) { logMessage("等待之前的线程结束", "Worker"); return; } // 等待线程完全结束并清理 m_workerThread->wait(); // 清理旧对象 if (m_worker) { m_worker->deleteLater(); m_worker = nullptr; } if (m_workerThread) { m_workerThread->deleteLater(); m_workerThread = nullptr; } // 处理事件循环，确保deleteLater执行 QCoreApplication::processEvents(); } m_workerStartBtn->setEnabled(false); m_workerStopBtn->setEnabled(true); m_workerProgressBar->setValue(0); m_workerResultLabel->setText("结果: 工作中..."); logMessage("启动Worker线程", "Worker"); // 创建新的Worker和Thread（无parent，以便moveToThread） m_worker = new Worker(); // 无parent m_workerThread = new QThread(); // 无parent // 移动Worker到线程（必须在无parent的情况下） m_worker->moveToThread(m_workerThread); // 连接Worker信号槽 connect(m_worker, &Worker::progress, this, &MainWindow::onWorkerProgress); connect(m_worker, &Worker::finished, this, &MainWindow::onWorkerFinished); connect(m_worker, &Worker::error, this, &MainWindow::onWorkerError); connect(m_workerThread, &QThread::started, m_worker, &Worker::doWork); // 线程结束时清理对象 connect(m_workerThread, &QThread::finished, this, [this]() { if (m_worker) { m_worker->deleteLater(); m_worker = nullptr; } if (m_workerThread) { m_workerThread->deleteLater(); m_workerThread = nullptr; } }); // 启动线程 m_workerThread->start(); } void MainWindow::onWorkerStop() { if (m_worker && m_workerThread && m_workerThread->isRunning()) { logMessage("请求停止Worker线程", "Worker"); // 停止Worker工作 if (m_worker) { m_worker->stopWork(); } // 退出线程 if (m_workerThread) { m_workerThread->quit(); if (!m_workerThread->wait(3000)) { logMessage("Worker线程未能在3秒内结束，强制终止", "Worker"); m_workerThread->terminate(); m_workerThread->wait(); } } m_workerStartBtn->setEnabled(true); m_workerStopBtn->setEnabled(false); logMessage("Worker线程已停止", "Worker"); } } void MainWindow::onWorkerProgress(int value) { m_workerProgressBar->setValue(value); logMessage(QString("进度: %1%").arg(value), "Worker"); } void MainWindow::onWorkerFinished(const QString &result) { m_workerProgressBar->setValue(100); m_workerResultLabel->setText(QString("结果: %1").arg(result)); m_workerStartBtn->setEnabled(true); m_workerStopBtn->setEnabled(false); logMessage(QString("工作完成: %1").arg(result), "Worker"); // 工作完成后，退出线程（对象会在finished信号中清理） if (m_workerThread && m_workerThread->isRunning()) { m_workerThread->quit(); } } void MainWindow::onWorkerError(const QString &error) { m_workerResultLabel->setText(QString("错误: %1").arg(error)); m_workerStartBtn->setEnabled(true); m_workerStopBtn->setEnabled(false); logMessage(QString("错误: %1").arg(error), "Worker"); } // 生产者-消费者模式槽函数实现 void MainWindow::onProducerConsumerStart() { int producerCount = m_producerCountSpinBox->value(); int consumerCount = m_consumerCountSpinBox->value(); int bufferSize = m_bufferSizeSpinBox->value(); m_producerConsumer->setProducerCount(producerCount); m_producerConsumer->setConsumerCount(consumerCount); m_producerConsumer->setBufferSize(bufferSize); m_pcStartBtn->setEnabled(false); m_pcStopBtn->setEnabled(true); m_processedItemsList->clear(); m_bufferProgressBar->setMaximum(bufferSize); m_bufferProgressBar->setValue(0); logMessage(QString("启动生产者-消费者模式 (生产者:%1, 消费者:%2, 缓冲区:%3)") .arg(producerCount).arg(consumerCount).arg(bufferSize), "ProducerConsumer"); m_producerConsumer->start(); } void MainWindow::onProducerConsumerStop() { m_producerConsumer->stop(); m_pcStartBtn->setEnabled(true); m_pcStopBtn->setEnabled(false); logMessage("停止生产者-消费者模式", "ProducerConsumer"); } void MainWindow::onBufferStatusChanged(int size, int maxSize) { m_bufferStatusLabel->setText(QString("缓冲区: %1/%2").arg(size).arg(maxSize)); m_bufferProgressBar->setMaximum(maxSize); m_bufferProgressBar->setValue(size); } void MainWindow::onItemProcessed(const QString &item) { m_processedItemsList->addItem(item); if (m_processedItemsList->count() > 100) { m_processedItemsList->takeItem(0); } logMessage(QString("已处理: %1").arg(item), "ProducerConsumer"); } // 线程池槽函数实现 void MainWindow::onThreadPoolStart() { int taskCount = m_taskCountSpinBox->value(); m_threadPoolStartBtn->setEnabled(false); m_threadPoolStopBtn->setEnabled(true); m_threadPoolProgressBar->setMaximum(taskCount); m_threadPoolProgressBar->setValue(0); m_threadPoolStatusLabel->setText(QString("状态: 执行中 (0/%1)").arg(taskCount)); m_threadPoolLog->clear(); logMessage(QString("开始执行 %1 个任务").arg(taskCount), "ThreadPool"); m_threadPoolManager->startTasks(taskCount); } void MainWindow::onThreadPoolStop() { m_threadPoolManager->stopTasks(); m_threadPoolStartBtn->setEnabled(true); m_threadPoolStopBtn->setEnabled(false); m_threadPoolStatusLabel->setText("状态: 已停止"); logMessage("停止任务执行", "ThreadPool"); } void MainWindow::onTaskCompleted(int taskId, const QString &result) { int completed = m_threadPoolProgressBar->value() + 1; int total = m_threadPoolProgressBar->maximum(); m_threadPoolProgressBar->setValue(completed); m_threadPoolStatusLabel->setText(QString("状态: 执行中 (%1/%2)").arg(completed).arg(total)); logMessage(QString("任务 %1 完成: %2").arg(taskId).arg(result), "ThreadPool"); } void MainWindow::onAllTasksCompleted() { m_threadPoolStartBtn->setEnabled(true); m_threadPoolStopBtn->setEnabled(false); m_threadPoolStatusLabel->setText("状态: 所有任务已完成"); logMessage("所有任务执行完成", "ThreadPool"); } // QtConcurrent槽函数实现 void MainWindow::onConcurrentStart() { int dataSize = m_dataSizeSpinBox->value(); m_concurrentStartBtn->setEnabled(false); m_concurrentStopBtn->setEnabled(true); m_concurrentProgressBar->setValue(0); m_concurrentResultLabel->setText("结果: 处理中..."); m_concurrentLog->clear(); logMessage(QString("开始并发处理 %1 个数据项").arg(dataSize), "Concurrent"); m_concurrentExample->startProcessing(dataSize); } void MainWindow::onConcurrentStop() { m_concurrentExample->stopProcessing(); m_concurrentStartBtn->setEnabled(true); m_concurrentStopBtn->setEnabled(false); m_concurrentResultLabel->setText("结果: 已停止"); logMessage("停止并发处理", "Concurrent"); } void MainWindow::onConcurrentProgress(int value) { m_concurrentProgressBar->setValue(value); } void MainWindow::onConcurrentFinished(const QString &result) { m_concurrentProgressBar->setValue(100); m_concurrentResultLabel->setText(QString("结果: %1").arg(result)); m_concurrentStartBtn->setEnabled(true); m_concurrentStopBtn->setEnabled(false); logMessage(QString("并发处理完成: %1").arg(result), "Concurrent"); }

Qt多线程编程的8个段位