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

相关推荐
qq_401700411 天前
Qt Positioning 模块访问设备地理位置信息
开发语言·qt
闫有尽意无琼1 天前
银河麒麟v11 arm编译Qt creator8.0.2报错
开发语言·qt
lqj_本人1 天前
鸿蒙Qt触控疑云：事件传递丢失与坐标偏移修复
qt·华为·harmonyos
_OP_CHEN1 天前
从零开始的Qt开发指南：（五）Qt 常用控件之 QWidget（上）：解锁 Qt 界面开发的核心基石
开发语言·c++·qt·前端开发·qwidget·gui开发·qt常用控件
happyjoey2171 天前
使用Qt自带的Maintenance Tool将Qt6.9升级为QT6.10
开发语言·qt
lqj_本人2 天前
鸿蒙Qt生命周期：后台被杀后的数据自救
qt·华为·harmonyos
爱码小白2 天前
PyQt5 QTimer总结
开发语言·qt
Jay Chou why did2 天前
13. Qt深入 样式表继承规则
qt
友友马2 天前
『Qt』多元素控件
开发语言·qt
热门推荐
01GitHub 镜像站点02【保姆级教程】免费使用Gemini3的5种方法！免翻墙/国内直连03BongoCat - 跨平台键盘猫动画工具04UV安装并设置国内源05安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）06Linux下V2Ray安装配置指南07Google Antigravity：无法登录？早期错误、登录修复和用户反馈指南08Labelme从安装到标注：零基础完整指南09全球最强模型Grok4，国内已可免费使用！（附教程）1046个Nano-banana 精选提示词，持续更新中