QtConcurrent 与 QFutureWatcher 实现高效异步计算

3. QFutureWatcher：监控异步操作

QFutureWatcher用于监控 QFuture的状态，通过信号 - 槽机制通知操作完成。

3.1 基本使用模式

class MyClass : public QObject {
    Q_OBJECT
private:
    QFutureWatcher<ResultType>* m_watcher;
public:
    void startAsyncOperation() {
        // 取消之前的操作
        if (m_watcher && m_watcher->isRunning()) {
            m_watcher->cancel();
            m_watcher->waitForFinished();
        }
        // 创建新的异步任务
        QFuture<ResultType> future = QtConcurrent::run(&heavyComputation);
        // 设置监视器
        m_watcher = new QFutureWatcher<ResultType>(this);
        connect(m_watcher, &QFutureWatcher<ResultType>::finished, this, &MyClass::onOperationFinished);
        m_watcher->setFuture(future);
    }
private slots:
    void onOperationFinished() {
        if (m_watcher->isCanceled()) {
            // 操作被取消
            return;
        }
        try {
            ResultType result = m_watcher->result();
            processResult(result);
        } catch (...) {
            handleError();
        }
        m_watcher->deleteLater();
        m_watcher = nullptr;
    }
};

3.2 进度监控

QFutureWatcher还支持进度监控：

// 连接进度信号
connect(m_watcher, &QFutureWatcher<void>::progressRangeChanged, this, &MyClass::onProgressRangeChanged);
connect(m_watcher, &QFutureWatcher<void>::progressValueChanged, this, &MyClass::onProgressValueChanged);

// 在异步函数中报告进度
QtConcurrent::run([](){
    for (int i = 0; i < 100; ++i) {
        performStep(i);
        QFutureInterface<void>::progressValueChanged(i + 1);
    }
});

4. 实战案例：异步颜色提取

让我们通过完整的颜色提取案例来演示实际应用。

4.1 C++异步实现

头文件定义：

class ImageColor : public QObject {
    Q_OBJECT
    Q_PROPERTY(int k READ k WRITE setK NOTIFY kChanged)
public:
    explicit ImageColor(QObject *parent = nullptr);
    
    // 同步版本（保持兼容性）
    Q_INVOKABLE QVector<QColor> getMainColors(const QImage &image);
    
    // 异步版本
    Q_INVOKABLE void getMainColorsAsync(const QImage &image);
    Q_INVOKABLE void cancelCurrentOperation();
    
signals:
    void colorsExtracted(const QVector<QColor>&colors);
    void extractionFailed();
    
private:
    int m_k = 3;
    QFutureWatcher<QVector<QColor>>* m_futureWatcher = nullptr;
    bool m_cancelled = false;
    
    // 线程安全的静态方法
    static QVector<QColor> extractColors(const QImage &image, int k);
    
private slots:
    void onAsyncOperationFinished();
};

实现文件：

ImageColor::ImageColor(QObject *parent) : QObject(parent), m_futureWatcher(nullptr), m_cancelled(false) {}

void ImageColor::getMainColorsAsync(const QImage &image) {
    // 取消之前的操作
    cancelCurrentOperation();
    m_cancelled = false;
    
    // 在后台线程执行
    QFuture<QVector<QColor>> future = QtConcurrent::run(&ImageColor::extractColors, image, m_k);
    
    // 设置监视器
    m_futureWatcher = new QFutureWatcher<QVector<QColor>>(this);
    connect(m_futureWatcher, &QFutureWatcher<QVector<QColor>>::finished, this, &ImageColor::onAsyncOperationFinished);
    m_futureWatcher->setFuture(future);
}

void ImageColor::cancelCurrentOperation() {
    m_cancelled = true;
    if (m_futureWatcher && m_futureWatcher->isRunning()) {
        m_futureWatcher->cancel();
        m_futureWatcher->waitForFinished();
    }
}

void ImageColor::onAsyncOperationFinished() {
    if (m_futureWatcher && m_futureWatcher->isFinished()) {
        if (!m_cancelled) {
            try {
                QVector<QColor> result = m_futureWatcher->result();
                emit colorsExtracted(result);
            } catch (...) {
                emit extractionFailed();
            }
        }
        m_futureWatcher->deleteLater();
        m_futureWatcher = nullptr;
    }
}

// 静态方法 - 线程安全
QVector<QColor> ImageColor::extractColors(const QImage &image, int k) {
    // 这里实现颜色提取算法
    // 注意：不能访问任何成员变量！
    QVector<QColor> result;
    // 简化的颜色提取逻辑
    if (image.isNull() || k <= 0) {
        return result;
    }
    // 实际的 k-means 聚类算法
    // ... 实现细节
    return result;
}

4.2 QML 集成

QML 端使用：

import QtQuick 2.15

Item {
    id: root
    
    Connections {
        target: p_imageColor
        onColorsExtracted: {
            console.log("异步颜色提取完成")
            applyColors(colors)
            _extractionInProgress = false
        }
        onExtractionFailed: {
            console.log("颜色提取失败")
            _extractionInProgress = false
        }
    }
    
    // 封面变化处理
    onCoverSourceChanged: {
        if (coverSource && !_extractionInProgress) {
            // 立即重置为默认颜色，提供即时反馈
            resetToDefaultColors()
            // 开始异步提取
            startAsyncExtraction(coverSource)
        }
    }
    
    function startAsyncExtraction(coverUrl) {
        _extractionInProgress = true
        // 加载图片
        var tempImage = Qt.createQmlObject(`
            Image {
                source: "${coverUrl}"
                asynchronous: true
                visible: false
            }
        `, root)
        
        // 监控图片加载状态
        var checkStatus = function() {
            if (tempImage.status === Image.Ready) {
                tempImage.grabToImage(function(result) {
                    if (result && result.image) {
                        // 调用异步 C++ 方法 - 不会阻塞 UI!
                        p_imageColor.getMainColorsAsync(result.image)
                    }
                    tempImage.destroy()
                })
            } else if (tempImage.status === Image.Error) {
                tempImage.destroy()
                _extractionInProgress = false
            } else {
                setTimeout(checkStatus, 50)
            }
        }
        setTimeout(checkStatus, 100)
    }
}

5. 注意事项

5.1 线程安全准则

1. 避免在后台线程中访问 GUI 对象：QObject 及其子类通常不是线程安全的
2. 使用值类型传递数据：QImage、QColor、QVector 等 Qt 值类型是线程安全的
3. 静态方法是最安全的选择：静态方法不访问成员变量，天然线程安全

5.2 内存管理

// 正确的资源清理
void MyClass::onOperationFinished() {
    if (m_watcher) {
        m_watcher->deleteLater(); // 安全删除
        m_watcher = nullptr;
    }
}

// 在析构函数中取消操作
MyClass::~MyClass() {
    if (m_watcher && m_watcher->isRunning()) {
        m_watcher->cancel();
        m_watcher->waitForFinished();
    }
}

5.3 错误处理

void MyClass::onOperationFinished() {
    if (m_watcher->isCanceled()) {
        // 用户取消操作
        return;
    }
    if (m_watcher->isFinished()) {
        try {
            auto result = m_watcher->result();
            processResult(result);
        } catch (const std::exception& e) {
            qWarning() << "Operation failed:" << e.what();
            handleError();
        }
    }
}

5.4 取消操作的处理

// 在耗时操作中定期检查取消状态
static QVector<QColor> extractColors(const QImage &image, std::atomic<bool>& cancelled) {
    QVector<QColor> result;
    for (int i = 0; i < maxIterations; ++i) {
        if (cancelled) {
            return QVector<QColor>(); // 提前返回
        }
        // ... 迭代计算
    }
    return result;
}

6. 性能优化技巧

6.1 减少数据拷贝

// 使用 const 引用传递大数据
static QVector<QColor> processImage(const QImage &image) {
    // image 以 const 引用传递，避免拷贝
    // ... 处理逻辑
}

6.2 合理设置线程数量

// 设置全局线程池大小
QThreadPool::globalInstance()->setMaxThreadCount(QThread::idealThreadCount());

6.3 批量处理

对于多个独立任务，可以使用 QtConcurrent::mapped()：

QList<QImage> images = getImagesToProcess();
QFuture<QVector<QColor>> future = QtConcurrent::mapped(images, &ImageColor::extractColors);

7. 总结

QtConcurrent和 QFutureWatcher为 Qt 应用程序提供了强大而简洁的异步编程能力。通过合理使用这些工具，我们可以：

• 保持 UI 响应性：耗时操作在后台执行
• 简化代码：相比手动管理 QThread，代码更简洁
• 自动资源管理：QtConcurrent 自动管理线程池
• 更好的用户体验：提供进度反馈和取消操作

在实际项目中，结合信号 - 槽机制和 QML 的响应式编程，可以构建出既高效又用户友好的应用程序。