ChatGLM3-6B模型并行训练实战：多GPU加速指南

一个简单的文件处理功能竟让整个界面卡死5秒——这种经历你是否也熟悉作为Qt开发者我们总在单线程的舒适区徘徊直到性能问题狠狠打脸。

今天我将用实际踩坑换来的经验带你彻底掌握Qt多线程的核心心法。

不是枯燥的API文档翻译而是能直接用到项目里的实战方案。

接下来的10分钟你会看到✅ 从‘线程恐慌’到‘并行掌控’的思维转变✅ 3种真实业务场景的多线程改造实录✅ 一行代码就能避免的常见崩溃陷阱如果你也曾在信号槽跨线程调用时一脸茫然面对QThread文档却不知从何下手担心多线程会让代码复杂度爆炸

基础概念体系

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

Qt线程模型线程亲和性Thread Affinity事件循环Event Loop线程局部存储对象树与线程关系

核心技术组件体系

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

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

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

编程范式与模式体系

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);

生产者-消费者模式// 使用QWaitCondition class Buffer { QMutex mutex; QWaitCondition bufferNotEmpty; QWaitCondition bufferNotFull; QListData buffer; int maxSize; void produce(Data data) { mutex.lock(); while(buffer.size() maxSize) { bufferNotFull.wait(mutex); } buffer.append(data); bufferNotEmpty.wakeAll(); mutex.unlock(); } };

Map-Reduce模式// 使用QtConcurrent QListint numbers {1, 2, 3, 4, 5}; QFutureint result QtConcurrent::mappedReduced( numbers, [](int n) { return n * n; }, // Map函数 [](int result, int value) { // Reduce函数 result value; } );

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

高级技术体系

异步编程// QFuture QFutureWatcher QFutureQImage future QtConcurrent::run(loadImage, file.png); QFutureWatcherQImage *watcher new QFutureWatcherQImage(); connect(watcher, QFutureWatcherQImage::finished, this, MyClass::handleImageLoaded); watcher-setFuture(future); // C20协程适配Qt6 QCoro::Task asyncOperation() { auto data co_await downloadDataAsync(); co_return processData(data); }

数据并行处理// 并行算法 QVectordouble vector(

; // 并行填充 QtConcurrent::blockingMap(vector, [](double value) { value expensiveComputation(); }); // 并行过滤 QVectordouble filtered QtConcurrent::blockingFiltered( vector, [](double value) { return value

5; });

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

调试与优化体系

线程调试技术// 线程命名Qt

10 thread-setObjectName(NetworkThread); // 获取线程信息 qDebug() Current thread: QThread::currentThread(); qDebug() Thread affinity: object-thread(); // 死锁检测 // 使用QDeadlineTimer设置超时 QMutex mutex; if(!mutex.tryLock(

) { // 1秒超时 qWarning() Possible deadlock detected!; }

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

内存管理// 正确释放资源 //

使用deleteLater worker-deleteLater(); thread-quit(); thread-wait(); //

QObject自动清理 QObject::connect(thread, QThread::finished, worker, QObject::deleteLater); QObject::connect(thread, QThread::finished, thread, QObject::deleteLater);

设计模式与最佳实践

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

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

测试策略单元测试中的线程测试竞态条件检测压力测试性能基准测试

Qt版本特性差异

Qt多线程工程实战案例

【工程项目】运行结果

1 Worker-Controller模式示例

2 生产者-消费者

3线程池

4QtConcurrent并发处理

【工程目录结构】

1工程目录结构

2工程项目架构整体架构图

3核心特性

2.

1Worker-Controller模式- ✅ 正确的线程生命周期管理- ✅ 信号槽跨线程通信- ✅ 优雅的停止机制- ✅ 实时进度更新

2.

2生产者-消费者模式- ✅ 多生产者/多消费者支持- ✅ 可配置缓冲区大小- ✅ 使用QMutex和QWaitCondition同步- ✅ 实时缓冲区状态监控

2.

3线程池模式- ✅ 自动线程复用- ✅ 任务队列管理- ✅ 并发任务执行- ✅ 实时任务进度跟踪

2.

4QtConcurrent框架- ✅ Map操作并行转换- ✅ Filter操作并行过滤- ✅ Reduce操作并行聚合- ✅ 平滑的进度条更新

【工程项目】部分代码

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

2worker.cpp#include worker.h #include QThread #include QDebug Worker::Worker(QObject *parent) : QObject(parent) , m_stopRequested(

, m_workDuration(

// 默认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

{ 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(

; }

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

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/%

).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(

; } // 清理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,

; resize(1200,

; // 创建中央部件 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(

; 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(

; m_workerProgressBar-setMaximum(

; m_workerProgressBar-setValue(

; 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(

; 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,

; m_producerCountSpinBox new QSpinBox(this); m_producerCountSpinBox-setMinimum(

; m_producerCountSpinBox-setMaximum(

; m_producerCountSpinBox-setValue(

; paramLayout-addWidget(m_producerCountSpinBox, 0,

; paramLayout-addWidget(new QLabel(消费者数量:, this), 0,

; m_consumerCountSpinBox new QSpinBox(this); m_consumerCountSpinBox-setMinimum(

; m_consumerCountSpinBox-setMaximum(

; m_consumerCountSpinBox-setValue(

; paramLayout-addWidget(m_consumerCountSpinBox, 0,

; paramLayout-addWidget(new QLabel(缓冲区大小:, this), 1,

; m_bufferSizeSpinBox new QSpinBox(this); m_bufferSizeSpinBox-setMinimum(

; m_bufferSizeSpinBox-setMaximum(

; m_bufferSizeSpinBox-setValue(

; paramLayout-addWidget(m_bufferSizeSpinBox, 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(

; m_bufferProgressBar-setMaximum(

; m_bufferProgressBar-setValue(

; 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,

; // 已处理项列表 QVBoxLayout *listLayout new QVBoxLayout(); listLayout-addWidget(new QLabel(已处理项:, this)); m_processedItemsList new QListWidget(this); listLayout-addWidget(m_processedItemsList); contentLayout-addLayout(listLayout,

; 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(

; m_taskCountSpinBox-setMaximum(

; m_taskCountSpinBox-setValue(

; 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(

; m_threadPoolProgressBar-setMaximum(

; m_threadPoolProgressBar-setValue(

; 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(

; m_dataSizeSpinBox-setMaximum(

; m_dataSizeSpinBox-setValue(

; 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(

; m_concurrentProgressBar-setMaximum(

; m_concurrentProgressBar-setValue(

; 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] %

.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(

; 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(

) { 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(

; m_workerResultLabel-setText(QString(结果: %

.arg(result)); m_workerStartBtn-setEnabled(true); m_workerStopBtn-setEnabled(false); logMessage(QString(工作完成: %

.arg(result), Worker); // 工作完成后退出线程对象会在finished信号中清理 if (m_workerThread m_workerThread-isRunning()) { m_workerThread-quit(); } } void MainWindow::onWorkerError(const QString error) { m_workerResultLabel-setText(QString(错误: %

.arg(error)); m_workerStartBtn-setEnabled(true); m_workerStopBtn-setEnabled(false); logMessage(QString(错误: %

.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(

; logMessage(QString(启动生产者-消费者模式 (生产者:%1, 消费者:%2, 缓冲区:%

) .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/%

.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()

{ m_processedItemsList-takeItem(

; } logMessage(QString(已处理: %

.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(

; m_threadPoolStatusLabel-setText(QString(状态: 执行中 (0/%

).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/%

).arg(completed).arg(total)); logMessage(QString(任务 %1 完成: %

.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(

; 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(

; m_concurrentResultLabel-setText(QString(结果: %

.arg(result)); m_concurrentStartBtn-setEnabled(true); m_concurrentStopBtn-setEnabled(false); logMessage(QString(并发处理完成: %

.arg(result), Concurrent); }

黄金网站app大全入口免费下载-黄金网站app大全入口免费下载应用