Qt中事件循环与并发机制的协同工作

qq_401700412025-11-28 12:09

1. Qt事件循环基础

1.1 事件循环的核心概念

Qt的事件循环是Qt应用程序的核心机制，负责处理事件分发、定时器、网络通信等异步操作。

cpp 复制代码 
#include <QCoreApplication>
#include <QEventLoop>
#include <QTimer>
#include <QDebug>

class EventLoopDemo : public QObject {
    Q_OBJECT
public:
    EventLoopDemo() {
        // 创建定时器
        m_timer = new QTimer(this);
        m_timer->setInterval(1000);
        connect(m_timer, &QTimer::timeout, this, &EventLoopDemo::onTimeout);
    }
    
    void startDemo() {
        qDebug() << "=== 事件循环基础演示 ===";
        qDebug() << "启动定时器，每秒触发一次";
        m_timer->start();
        
        // 创建局部事件循环
        QEventLoop localLoop;
        QTimer::singleShot(5000, &localLoop, &QEventLoop::quit);
        
        qDebug() << "进入局部事件循环，5秒后退出";
        localLoop.exec();
        qDebug() << "局部事件循环退出";
        
        m_timer->stop();
    }

private slots:
    void onTimeout() {
        static int count = 0;
        qDebug() << "定时器触发:" << ++count << " - 线程:" << QThread::currentThread();
    }

private:
    QTimer* m_timer;
};

1.2 嵌套事件循环

cpp 复制代码 
#include <QDialog>
#include <QVBoxLayout>
#include <QPushButton>
#include <QMessageBox>

class NestedEventLoopDemo : public QDialog {
    Q_OBJECT
public:
    NestedEventLoopDemo(QWidget* parent = nullptr) : QDialog(parent) {
        setWindowTitle("嵌套事件循环演示");
        auto layout = new QVBoxLayout(this);
        
        auto btnStart = new QPushButton("开始嵌套事件循环测试", this);
        auto btnModal = new QPushButton("打开模态对话框", this);
        auto btnQuit = new QPushButton("退出", this);
        
        layout->addWidget(btnStart);
        layout->addWidget(btnModal);
        layout->addWidget(btnQuit);
        
        connect(btnStart, &QPushButton::clicked, this, &NestedEventLoopDemo::onStartTest);
        connect(btnModal, &QPushButton::clicked, this, &NestedEventLoopDemo::onOpenModal);
        connect(btnQuit, &QPushButton::clicked, this, &QDialog::accept);
        
        m_timer = new QTimer(this);
        connect(m_timer, &QTimer::timeout, this, &NestedEventLoopDemo::onTimer);
    }

private slots:
    void onStartTest() {
        qDebug() << "开始嵌套事件循环测试";
        
        // 第一层事件循环
        QEventLoop loop1;
        QTimer::singleShot(2000, &loop1, &QEventLoop::quit);
        
        qDebug() << "进入第一层事件循环 (2秒)";
        m_timer->start(500);
        loop1.exec();
        m_timer->stop();
        qDebug() << "退出第一层事件循环";
        
        // 第二层事件循环
        QEventLoop loop2;
        QTimer::singleShot(2000, &loop2, &QEventLoop::quit);
        
        qDebug() << "进入第二层事件循环 (2秒)";
        m_timer->start(500);
        loop2.exec();
        m_timer->stop();
        qDebug() << "退出第二层事件循环";
        
        qDebug() << "嵌套事件循环测试完成";
    }
    
    void onOpenModal() {
        qDebug() << "打开模态对话框 - 将进入新的事件循环";
        QMessageBox::information(this, "模态对话框", "这是一个模态对话框");
        qDebug() << "模态对话框关闭 - 退出事件循环";
    }
    
    void onTimer() {
        static int count = 0;
        qDebug() << "定时器运行中..." << ++count;
    }

private:
    QTimer* m_timer;
};

2. Qt并发编程基础

2.1 QThread 基础用法

cpp 复制代码 
#include <QThread>
#include <QDebug>
#include <QMutex>
#include <QWaitCondition>

class WorkerThread : public QThread {
    Q_OBJECT
public:
    explicit WorkerThread(const QString& name, QObject* parent = nullptr) 
        : QThread(parent), m_name(name), m_stopRequested(false) {}
    
    void stop() {
        QMutexLocker locker(&m_mutex);
        m_stopRequested = true;
        m_condition.wakeOne();
    }

protected:
    void run() override {
        qDebug() << m_name << "线程开始运行，线程ID:" << currentThreadId();
        
        int count = 0;
        while (!m_stopRequested && count < 10) {
            {
                QMutexLocker locker(&m_mutex);
                m_condition.wait(&m_mutex, 1000); // 等待1秒或停止信号
            }
            
            if (!m_stopRequested) {
                count++;
                qDebug() << m_name << "处理任务:" << count << "- 线程:" << currentThreadId();
                emit progressUpdated(count * 10);
            }
        }
        
        qDebug() << m_name << "线程结束运行";
        emit finished();
    }

signals:
    void progressUpdated(int percent);
    void finished();

private:
    QString m_name;
    QMutex m_mutex;
    QWaitCondition m_condition;
    bool m_stopRequested;
};

class ThreadManager : public QObject {
    Q_OBJECT
public:
    ThreadManager() {
        m_worker1 = new WorkerThread("工作线程1");
        m_worker2 = new WorkerThread("工作线程2");
        
        connect(m_worker1, &WorkerThread::progressUpdated, this, &ThreadManager::onWorker1Progress);
        connect(m_worker2, &WorkerThread::progressUpdated, this, &ThreadManager::onWorker2Progress);
        connect(m_worker1, &WorkerThread::finished, this, &ThreadManager::onWorkerFinished);
        connect(m_worker2, &WorkerThread::finished, this, &ThreadManager::onWorkerFinished);
    }
    
    ~ThreadManager() {
        stopAll();
        m_worker1->wait();
        m_worker2->wait();
        delete m_worker1;
        delete m_worker2;
    }
    
    void startAll() {
        qDebug() << "启动所有工作线程";
        m_worker1->start();
        m_worker2->start();
    }
    
    void stopAll() {
        qDebug() << "停止所有工作线程";
        m_worker1->stop();
        m_worker2->stop();
    }

private slots:
    void onWorker1Progress(int percent) {
        qDebug() << "主线程收到工作线程1进度:" << percent << "%";
    }
    
    void onWorker2Progress(int percent) {
        qDebug() << "主线程收到工作线程2进度:" << percent << "%";
    }
    
    void onWorkerFinished() {
        qDebug() << "工作线程完成";
    }

private:
    WorkerThread* m_worker1;
    WorkerThread* m_worker2;
};

2.2 移动对象到线程（moveToThread）

cpp 复制代码 
#include <QObject>
#include <QThread>
#include <QTimer>

class WorkerObject : public QObject {
    Q_OBJECT
public:
    WorkerObject() : m_counter(0) {
        m_timer = new QTimer(this);
        connect(m_timer, &QTimer::timeout, this, &WorkerObject::doWork);
    }
    
    ~WorkerObject() {
        qDebug() << "WorkerObject 析构，线程:" << QThread::currentThread();
    }

public slots:
    void startWork() {
        qDebug() << "WorkerObject 开始工作，线程:" << QThread::currentThread();
        m_timer->start(1000);
    }
    
    void stopWork() {
        qDebug() << "WorkerObject 停止工作";
        m_timer->stop();
        emit workStopped();
    }
    
    void doWork() {
        m_counter++;
        qDebug() << "执行工作:" << m_counter << "- 线程:" << QThread::currentThread();
        emit workProgress(m_counter);
        
        if (m_counter >= 5) {
            stopWork();
        }
    }

signals:
    void workProgress(int count);
    void workStopped();

private:
    QTimer* m_timer;
    int m_counter;
};

class ThreadController : public QObject {
    Q_OBJECT
public:
    ThreadController() {
        // 创建工作线程
        m_workerThread = new QThread(this);
        
        // 创建工作对象（在主线程创建）
        m_worker = new WorkerObject();
        
        // 将工作对象移动到工作线程
        m_worker->moveToThread(m_workerThread);
        
        // 连接信号槽 - 注意：这些连接是跨线程的
        connect(m_workerThread, &QThread::started, m_worker, &WorkerObject::startWork);
        connect(m_worker, &WorkerObject::workStopped, m_workerThread, &QThread::quit);
        connect(m_workerThread, &QThread::finished, m_worker, &QObject::deleteLater);
        connect(m_workerThread, &QThread::finished, this, &ThreadController::onThreadFinished);
        connect(m_worker, &WorkerObject::workProgress, this, &ThreadController::onWorkProgress);
    }
    
    ~ThreadController() {
        if (m_workerThread->isRunning()) {
            m_workerThread->quit();
            m_workerThread->wait();
        }
    }
    
    void start() {
        qDebug() << "启动工作线程";
        m_workerThread->start();
    }

private slots:
    void onWorkProgress(int count) {
        qDebug() << "主线程收到工作进度:" << count;
    }
    
    void onThreadFinished() {
        qDebug() << "工作线程结束";
    }

private:
    QThread* m_workerThread;
    WorkerObject* m_worker;
};

3. 事件循环与线程的协同

3.1 线程中的事件循环

cpp 复制代码 
#include <QThread>
#include <QTimer>
#include <QNetworkAccessManager>
#include <QNetworkReply>

class NetworkWorker : public QObject {
    Q_OBJECT
public:
    NetworkWorker() {
        m_manager = new QNetworkAccessManager(this);
    }

public slots:
    void startRequests() {
        qDebug() << "网络工作器开始，线程:" << QThread::currentThread();
        
        // 在工作者线程中执行网络请求
        performRequest("https://httpbin.org/delay/1");
        performRequest("https://httpbin.org/delay/2");
        performRequest("https://httpbin.org/delay/1");
    }
    
    void performRequest(const QString& url) {
        QNetworkRequest request(QUrl(url));
        QNetworkReply* reply = m_manager->get(request);
        
        connect(reply, &QNetworkReply::finished, [this, reply, url]() {
            if (reply->error() == QNetworkReply::NoError) {
                qDebug() << "请求完成:" << url << "- 线程:" << QThread::currentThread();
                m_completedRequests++;
                emit requestCompleted(m_completedRequests);
            } else {
                qDebug() << "请求失败:" << url << reply->errorString();
            }
            
            reply->deleteLater();
            
            // 所有请求完成后发出信号
            if (m_completedRequests >= 3) {
                emit allRequestsCompleted();
            }
        });
    }

signals:
    void requestCompleted(int count);
    void allRequestsCompleted();

private:
    QNetworkAccessManager* m_manager;
    int m_completedRequests = 0;
};

class EventLoopInThreadDemo : public QObject {
    Q_OBJECT
public:
    void demonstrate() {
        qDebug() << "=== 线程中的事件循环演示 ===";
        qDebug() << "主线程:" << QThread::currentThread();
        
        QThread* workerThread = new QThread;
        NetworkWorker* worker = new NetworkWorker;
        
        worker->moveToThread(workerThread);
        
        // 连接信号槽
        connect(workerThread, &QThread::started, worker, &NetworkWorker::startRequests);
        connect(worker, &NetworkWorker::allRequestsCompleted, workerThread, &QThread::quit);
        connect(workerThread, &QThread::finished, worker, &QObject::deleteLater);
        connect(workerThread, &QThread::finished, workerThread, &QObject::deleteLater);
        connect(worker, &NetworkWorker::requestCompleted, this, [](int count) {
            qDebug() << "主线程收到完成信号，完成数量:" << count;
        });
        
        // 启动线程（线程内部会自动运行事件循环）
        workerThread->start();
        
        // 等待线程完成
        if (workerThread->wait(10000)) {
            qDebug() << "所有网络请求完成";
        } else {
            qDebug() << "网络请求超时";
        }
    }
};

3.2 跨线程事件传递

cpp 复制代码 
#include <QCoreApplication>
#include <QThread>
#include <QTimer>
#include <QMutex>
#include <QQueue>

class CrossThreadEventProcessor : public QObject {
    Q_OBJECT
public:
    CrossThreadEventProcessor() {
        m_timer = new QTimer(this);
        connect(m_timer, &QTimer::timeout, this, &CrossThreadEventProcessor::processEvents);
    }
    
    void postEvent(const QString& event) {
        QMutexLocker locker(&m_mutex);
        m_eventQueue.enqueue(event);
        
        // 如果不在处理中，启动定时器
        if (!m_processing) {
            m_timer->start(0); // 下一个事件循环迭代时处理
        }
    }

private slots:
    void processEvents() {
        m_processing = true;
        m_timer->stop();
        
        QStringList eventsToProcess;
        {
            QMutexLocker locker(&m_mutex);
            while (!m_eventQueue.isEmpty()) {
                eventsToProcess.append(m_eventQueue.dequeue());
            }
        }
        
        for (const QString& event : eventsToProcess) {
            qDebug() << "处理事件:" << event << "- 线程:" << QThread::currentThread();
            QThread::msleep(100); // 模拟处理时间
            emit eventProcessed(event);
        }
        
        {
            QMutexLocker locker(&m_mutex);
            if (m_eventQueue.isEmpty()) {
                m_processing = false;
            } else {
                m_timer->start(0); // 还有事件，继续处理
            }
        }
    }

signals:
    void eventProcessed(const QString& event);

private:
    QTimer* m_timer;
    QMutex m_mutex;
    QQueue<QString> m_eventQueue;
    bool m_processing = false;
};

class EventProducer : public QObject {
    Q_OBJECT
public:
    EventProducer(CrossThreadEventProcessor* processor) : m_processor(processor) {
        m_timer = new QTimer(this);
        connect(m_timer, &QTimer::timeout, this, &EventProducer::generateEvent);
    }
    
    void startProducing() {
        m_timer->start(200);
    }
    
    void stopProducing() {
        m_timer->stop();
    }

private slots:
    void generateEvent() {
        static int eventId = 0;
        QString event = QString("Event_%1").arg(++eventId);
        qDebug() << "产生事件:" << event << "- 线程:" << QThread::currentThread();
        m_processor->postEvent(event);
    }

private:
    CrossThreadEventProcessor* m_processor;
    QTimer* m_timer;
};

4. Qt Concurrent 框架

4.1 QtConcurrent 基础用法

cpp 复制代码 
#include <QtConcurrent>
#include <QFuture>
#include <QFutureWatcher>
#include <QVector>
#include <QMap>

class ConcurrentDemo : public QObject {
    Q_OBJECT
public:
    void demonstrateBasics() {
        qDebug() << "=== QtConcurrent 基础演示 ===";
        
        // 1. 运行简单函数
        QFuture<void> future1 = QtConcurrent::run([]() {
            qDebug() << "在并发线程中执行简单函数 - 线程:" << QThread::currentThread();
            QThread::sleep(2);
        });
        
        future1.waitForFinished();
        qDebug() << "简单函数执行完成";
        
        // 2. 映射操作
        QVector<int> data = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        
        QFuture<int> future2 = QtConcurrent::mappedReduced(
            data,
            [](int value) -> int {
                qDebug() << "处理数据:" << value << "- 线程:" << QThread::currentThread();
                QThread::msleep(100);
                return value * value;
            },
            [](int& result, int value) {
                result += value;
            }
        );
        
        QFutureWatcher<int> watcher;
        watcher.setFuture(future2);
        
        QEventLoop loop;
        connect(&watcher, &QFutureWatcher<int>::finished, &loop, &QEventLoop::quit);
        loop.exec();
        
        qDebug() << "映射归约结果:" << future2.result();
        
        // 3. 过滤操作
        QFuture<void> future3 = QtConcurrent::filter(data, [](int value) {
            return value % 2 == 0; // 只保留偶数
        });
        
        future3.waitForFinished();
        qDebug() << "过滤后的数据:";
        for (int value : data) {
            qDebug() << value;
        }
    }
    
    void demonstrateAdvanced() {
        qDebug() << "\n=== QtConcurrent 高级演示 ===";
        
        // 使用 QFutureWatcher 监控进度
        QVector<int> data;
        for (int i = 0; i < 100; ++i) {
            data.append(i);
        }
        
        QFuture<QMap<int, int>> future = QtConcurrent::mappedReduced(
            data,
            [](int value) -> QMap<int, int> {
                QThread::msleep(10); // 模拟工作
                int remainder = value % 5;
                return QMap<int, int>{{remainder, value}};
            },
            &ConcurrentDemo::reduceFunction
        );
        
        QFutureWatcher<QMap<int, int>> watcher;
        connect(&watcher, &QFutureWatcher<QMap<int, int>>::progressRangeChanged, 
                [](int min, int max) {
                    qDebug() << "进度范围:" << min << "-" << max;
                });
        
        connect(&watcher, &QFutureWatcher<QMap<int, int>>::progressValueChanged, 
                [](int progress) {
                    qDebug() << "处理进度:" << progress << "%";
                });
        
        connect(&watcher, &QFutureWatcher<QMap<int, int>>::finished, 
                [&future]() {
                    auto result = future.result();
                    qDebug() << "处理完成，结果:";
                    for (auto it = result.begin(); it != result.end(); ++it) {
                        qDebug() << "余数" << it.key() << "的和:" << it.value();
                    }
                });
        
        watcher.setFuture(future);
        
        QEventLoop loop;
        connect(&watcher, &QFutureWatcher<QMap<int, int>>::finished, &loop, &QEventLoop::quit);
        loop.exec();
    }

private:
    static void reduceFunction(QMap<int, int>& result, const QMap<int, int>& value) {
        for (auto it = value.begin(); it != value.end(); ++it) {
            result[it.key()] += it.value();
        }
    }
};

4.2 并行算法与事件循环集成

cpp 复制代码 
#include <QtConcurrent>
#include <QFutureSynchronizer>
#include <QProgressDialog>

class ParallelAlgorithmIntegration : public QObject {
    Q_OBJECT
public:
    void demonstrateWithUI() {
        qDebug() << "=== 并行算法与UI集成演示 ===";
        
        // 模拟大量数据
        QVector<QImage> images;
        for (int i = 0; i < 50; ++i) {
            images.append(QImage(100, 100, QImage::Format_RGB32));
        }
        
        // 创建进度对话框
        QProgressDialog progressDialog;
        progressDialog.setLabelText("处理图像中...");
        progressDialog.setRange(0, images.size());
        progressDialog.setCancelButtonText("取消");
        progressDialog.show();
        
        // 使用 QFutureSynchronizer 管理多个future
        QFutureSynchronizer<void> synchronizer;
        
        QFutureWatcher<void> watcher;
        int processedCount = 0;
        
        connect(&watcher, &QFutureWatcher<void>::progressValueChanged, 
                [&progressDialog, &processedCount](int progress) {
                    processedCount = progress;
                    progressDialog.setValue(progress);
                });
        
        // 并行处理图像
        QFuture<void> future = QtConcurrent::map(images, [](QImage& image) {
            // 模拟图像处理
            QThread::msleep(100);
            image = image.mirrored(true, false);
        });
        
        watcher.setFuture(future);
        synchronizer.addFuture(future);
        
        // 连接取消按钮
        connect(&progressDialog, &QProgressDialog::canceled, &synchronizer, &QFutureSynchronizer::cancelAllFutures);
        
        // 等待完成
        QEventLoop loop;
        connect(&watcher, &QFutureWatcher<void>::finished, &loop, &QEventLoop::quit);
        loop.exec();
        
        if (future.isCanceled()) {
            qDebug() << "处理被用户取消";
        } else {
            qDebug() << "图像处理完成，共处理" << processedCount << "张图像";
        }
    }
    
    void demonstrateChainedOperations() {
        qDebug() << "\n=== 链式并行操作演示 ===";
        
        QVector<int> data = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        
        // 链式操作: 过滤 -> 映射 -> 归约
        QFuture<int> future = QtConcurrent::filtered(data, [](int x) { return x % 2 == 0; })
                                .map([](int x) { return x * x; })
                                .reduced([](int& result, int x) { result += x; }, 0);
        
        QFutureWatcher<int> watcher;
        watcher.setFuture(future);
        
        QEventLoop loop;
        connect(&watcher, &QFutureWatcher<int>::finished, &loop, &QEventLoop::quit);
        loop.exec();
        
        qDebug() << "链式操作结果 (偶数的平方和):" << future.result();
    }
};

5. 高级协同模式

5.1 生产者-消费者模式

cpp 复制代码 
#include <QThread>
#include <QWaitCondition>
#include <QMutex>
#include <QQueue>

template<typename T>
class ThreadSafeQueue {
public:
    void enqueue(const T& value) {
        QMutexLocker locker(&m_mutex);
        m_queue.enqueue(value);
        m_condition.wakeOne();
    }
    
    T dequeue() {
        QMutexLocker locker(&m_mutex);
        while (m_queue.isEmpty() && !m_stopped) {
            m_condition.wait(&m_mutex);
        }
        
        if (m_stopped) {
            return T();
        }
        
        return m_queue.dequeue();
    }
    
    bool isEmpty() const {
        QMutexLocker locker(&m_mutex);
        return m_queue.isEmpty();
    }
    
    int size() const {
        QMutexLocker locker(&m_mutex);
        return m_queue.size();
    }
    
    void stop() {
        QMutexLocker locker(&m_mutex);
        m_stopped = true;
        m_condition.wakeAll();
    }

private:
    mutable QMutex m_mutex;
    QWaitCondition m_condition;
    QQueue<T> m_queue;
    bool m_stopped = false;
};

class Producer : public QObject {
    Q_OBJECT
public:
    Producer(ThreadSafeQueue<QString>* queue, int id) 
        : m_queue(queue), m_id(id), m_counter(0) {}
    
    void startProducing() {
        m_timer = new QTimer(this);
        connect(m_timer, &QTimer::timeout, this, &Producer::produceItem);
        m_timer->start(500); // 每500ms生产一个项目
    }
    
    void stopProducing() {
        if (m_timer) {
            m_timer->stop();
        }
    }

private slots:
    void produceItem() {
        QString item = QString("Producer%1_Item%2").arg(m_id).arg(++m_counter);
        m_queue->enqueue(item);
        qDebug() << "生产者" << m_id << "生产:" << item;
        
        if (m_counter >= 10) {
            stopProducing();
            emit finished();
        }
    }

signals:
    void finished();

private:
    ThreadSafeQueue<QString>* m_queue;
    int m_id;
    int m_counter;
    QTimer* m_timer = nullptr;
};

class Consumer : public QObject {
    Q_OBJECT
public:
    Consumer(ThreadSafeQueue<QString>* queue, int id) 
        : m_queue(queue), m_id(id) {}
    
    void startConsuming() {
        // 在工作线程中运行消费循环
        QThread* thread = QThread::create([this]() {
            qDebug() << "消费者" << m_id << "开始运行，线程:" << QThread::currentThread();
            
            while (true) {
                QString item = m_queue->dequeue();
                if (item.isEmpty()) {
                    break; // 队列已停止
                }
                
                qDebug() << "消费者" << m_id << "消费:" << item;
                QThread::msleep(1000); // 模拟消费时间
                
                emit itemConsumed(item);
            }
            
            qDebug() << "消费者" << m_id << "结束运行";
            emit finished();
        });
        
        connect(thread, &QThread::finished, thread, &QThread::deleteLater);
        thread->start();
    }

signals:
    void itemConsumed(const QString& item);
    void finished();

private:
    ThreadSafeQueue<QString>* m_queue;
    int m_id;
};

class ProducerConsumerDemo : public QObject {
    Q_OBJECT
public:
    void demonstrate() {
        qDebug() << "=== 生产者-消费者模式演示 ===";
        
        ThreadSafeQueue<QString> queue;
        
        // 创建生产者
        Producer producer1(&queue, 1);
        Producer producer2(&queue, 2);
        
        // 创建消费者
        Consumer consumer1(&queue, 1);
        Consumer consumer2(&queue, 2);
        
        // 连接信号
        connect(&producer1, &Producer::finished, this, &ProducerConsumerDemo::onProducerFinished);
        connect(&producer2, &Producer::finished, this, &ProducerConsumerDemo::onProducerFinished);
        connect(&consumer1, &Consumer::finished, this, &ProducerConsumerDemo::onConsumerFinished);
        connect(&consumer2, &Consumer::finished, this, &ProducerConsumerDemo::onConsumerFinished);
        
        // 启动消费者
        consumer1.startConsuming();
        consumer2.startConsuming();
        
        // 启动生产者
        producer1.startProducing();
        producer2.startProducing();
        
        // 设置停止计时器
        QTimer::singleShot(15000, [&queue]() {
            qDebug() << "停止队列";
            queue.stop();
        });
        
        m_producerCount = 2;
        m_consumerCount = 2;
    }

private slots:
    void onProducerFinished() {
        m_producerCount--;
        qDebug() << "生产者完成，剩余:" << m_producerCount;
    }
    
    void onConsumerFinished() {
        m_consumerCount--;
        qDebug() << "消费者完成，剩余:" << m_consumerCount;
    }

private:
    int m_producerCount = 0;
    int m_consumerCount = 0;
};

5.2 异步操作与事件循环集成

cpp 复制代码 
#include <QPromise>
#include <QFuture>
#include <QTimer>

class AsyncOperationManager : public QObject {
    Q_OBJECT
public:
    QFuture<QString> startAsyncOperation(const QString& input) {
        // 使用 QPromise 创建异步操作
        QPromise<QString> promise;
        QFuture<QString> future = promise.future();
        
        // 在单独的线程中执行异步操作
        QtConcurrent::run([this, promise, input]() mutable {
            try {
                qDebug() << "开始异步操作，输入:" << input << "- 线程:" << QThread::currentThread();
                
                // 模拟工作进度
                for (int i = 0; i <= 100; i += 20) {
                    if (promise.isCanceled()) {
                        throw std::runtime_error("操作被取消");
                    }
                    
                    QThread::msleep(200);
                    promise.setProgressValue(i);
                    qDebug() << "操作进度:" << i << "%";
                }
                
                QString result = QString("处理完成: %1").arg(input.toUpper());
                promise.addResult(result);
                promise.finish();
                
            } catch (const std::exception& e) {
                promise.setException(std::current_exception());
                promise.finish();
            }
        });
        
        return future;
    }
    
    void demonstrateChainedAsyncOperations() {
        qDebug() << "=== 链式异步操作演示 ===";
        
        // 第一个异步操作
        QFuture<QString> future1 = startAsyncOperation("hello");
        
        // 当第一个操作完成时，启动第二个操作
        QFutureWatcher<QString> watcher1;
        connect(&watcher1, &QFutureWatcher<QString>::finished, [this, &watcher1]() {
            try {
                QString result1 = watcher1.result();
                qDebug() << "第一个操作完成:" << result1;
                
                // 启动第二个操作
                QFuture<QString> future2 = startAsyncOperation(result1);
                
                QFutureWatcher<QString> watcher2;
                connect(&watcher2, &QFutureWatcher<QString>::finished, [&watcher2]() {
                    try {
                        QString result2 = watcher2.result();
                        qDebug() << "第二个操作完成:" << result2;
                    } catch (const std::exception& e) {
                        qDebug() << "第二个操作失败:" << e.what();
                    }
                });
                
                watcher2.setFuture(future2);
                
            } catch (const std::exception& e) {
                qDebug() << "第一个操作失败:" << e.what();
            }
        });
        
        watcher1.setFuture(future1);
    }
};

// 完整示例程序
int main(int argc, char *argv[]) {
    QCoreApplication app(argc, argv);
    
    qDebug() << "=== Qt事件循环与并发机制协同工作完整演示 ===";
    
    // 演示各个功能
    EventLoopDemo eventDemo;
    eventDemo.startDemo();
    
    ThreadController threadCtrl;
    threadCtrl.start();
    
    EventLoopInThreadDemo eventThreadDemo;
    eventThreadDemo.demonstrate();
    
    ConcurrentDemo concurrentDemo;
    concurrentDemo.demonstrateBasics();
    concurrentDemo.demonstrateAdvanced();
    
    ProducerConsumerDemo pcDemo;
    pcDemo.demonstrate();
    
    AsyncOperationManager asyncManager;
    asyncManager.demonstrateChainedAsyncOperations();
    
    qDebug() << "\n=== 演示完成 ===";
    
    return app.exec();
}

#include "main.moc"

6. 关键要点总结

6.1 事件循环核心要点

  1. 主事件循环：每个Qt应用都有一个主事件循环，负责处理所有事件

  2. 嵌套事件循环：可以创建局部事件循环，但要谨慎使用避免复杂性

  3. 线程事件循环：每个线程可以有独立的事件循环

  4. 事件传递：Qt自动处理跨线程事件传递

6.2 并发编程最佳实践

  1. moveToThread模式：将对象移动到工作线程，利用信号槽进行通信

  2. 线程安全：使用QMutex、QReadWriteLock等保护共享数据

  3. QtConcurrent：高级API，简化并行编程

  4. Future模式：使用QFuture和QFutureWatcher监控异步操作

6.3 协同工作模式

  1. 生产者-消费者：使用线程安全队列协调不同线程

  2. 工作线程模式：长时间任务在工作线程执行，通过信号通知主线程

  3. 并行算法：使用QtConcurrent利用多核CPU

  4. 异步操作链：将多个异步操作串联执行

通过合理结合Qt的事件循环和并发机制，可以构建出响应迅速、高效利用系统资源的应用程序。关键在于理解不同场景下最适合的模式，并正确管理线程间的通信和同步。

相关推荐
用户805533698034 天前
不止三件套：QObject 属性系统全关键字与运行时反射!
c++·qt
xcyxiner4 天前
DicomViewer (vcpkg Windows和ubuntu编译)7
qt
Quz9 天前
QML Hello World 入门示例
qt
xcyxiner12 天前
DicomViewer (dcmtk读取dcm文件)5
qt
xcyxiner13 天前
DicomViewer (后台线程处理文件)4
qt
xcyxiner13 天前
DicomViewer (添加模型类)3
qt
xcyxiner14 天前
DicomViewer (目录调整) 2
qt
xcyxiner14 天前
dcmtk vtk vtk-dicom(gdcm) 编译(debug) v2
qt
桥田智能16 天前
桥田智能 QT-650S：面向白车身焊装的 800kg 重载快换解决方案
开发语言·qt·系统架构
森G16 天前
75、服务器源码解析---------云视频服务项目
linux·服务器·网络·c++·qt
热门推荐
012026 年 AI 编程工具终极横评：Cursor vs Claude Code vs Copilot vs Windsurf02GitHub 镜像站点03【AI】2026 年具身智能模型和世界模型总结042026年6月AI大模型全景报告：GPT-5.6、Claude Opus 4.8、Gemini 3.5，中美AI三足鼎立谁主沉浮？052026 AI 编程工具终极实战指南：Cursor vs Claude Code vs Copilot，开发者该怎么选？06Claude Code、Codex、Cursor三分天下：2026年AI编程Agent生态全景剖析072026年6月AI行业全景：从百模大战到Agent元年，这30天发生了什么？082026 年 AI 大模型 & AI 编程工具实战全总结09Trae国际版与国内版深度测评：AI原生IDE的双生花10AI科技热点日报 | 2026年07月01日