Qt之QFuture

简述

QFuture 类代表一个异步计算的结果。

要启动一个计算，使用 Qt之Concurrent框架 中的 APIs 之一。

QFuture 允许线程与一个或多个结果同步，这些结果将在稍后的时间点准备就绪，该结果可以是具有默认构造函数和拷贝构造函数的任何类型。如果一个结果在调用 result()、resultAt() 或 results() 函数时不可用，QFuture 将进行等待，直到结果可用为止，使用 isResultReadyAt() 函数可以检测结果是否已准备就绪。

进度信息由 progressValue()、progressMinimum()、progressMaximum() 和 progressText() 函数提供。

基本使用

要在另一个线程中运行函数，使用 QtConcurrent::run()：

#include 
#include 
#include 

void hello(const QString &name)
{
    qDebug() << "Hello" << name << "from" << QThread::currentThread();
}

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    qDebug() << "Main Thread" << QThread::currentThread();

    // 在一个单独的线程中调用 hello()
    QFuture<void> f1 = QtConcurrent::run(hello, QString("Qter"));
    QFuture<void> f2 = QtConcurrent::run(hello, QString("Pythoner"));

    // 阻塞调用线程并等待计算完成，确保所有结果可用
    f1.waitForFinished();
    f2.waitForFinished();
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23

这时，输出如下：

Main Thread QThread(0x398fc0) 
Hello “Qter” from QThread(0x39c240, name = “Thread (pooled)”) 
Hello “Pythoner” from QThread(0x39c280, name = “Thread (pooled)”)

显然，主线程与另外两个线程均不同。

QFuture  专用于获取不包含任何结果的函数，任何 QFuture  都可以分配或复制到 QFuture 。如果只需要状态或进度信息，而不需要实际结果数据，这是非常有用的。

高级操作

QFuture 还提供了很多方法与正在进行的异步调用进行交互。例如，使用 cancel() 函数取消计算；要暂停计算，使用 setPaused() 函数或 pause()，resume()、togglePaused() 便利函数之一。

助手中有很关键的一句话：

Be aware that not all asynchronous computations can be canceled or paused. For example, the future returned by QtConcurrent::run() cannot be canceled; but the future returned by QtConcurrent::mappedReduced() can

意思是说，并非所有异步计算都可以取消或暂停。例如，QtConcurrent::run() 返回的 future 不能被取消，但 QtConcurrent::mappedReduced() 返回的可以。

来看一个对一组图像进行缩放的示例：

#include 
#include 
#include 
#include 

QImage scale(const QImage &image)
{
    qDebug() << "Scaling image in thread" << QThread::currentThread();
    return image.scaled(QSize(100, 100), Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
}

int main(int argc, char *argv[])
{
    QGuiApplication app(argc, argv);

    const int imageCount = 20;

    // 创建一个列表包含 imageCount 个图像
    QList images;
    for (int i = 0; i < imageCount; ++i)
        images.append(QImage(1600, 1200, QImage::Format_ARGB32_Premultiplied));

    // 使用 QtConcurrent::mapped 对每个图像应用 scale 函数（缩放）
    QFuture thumbnails = QtConcurrent::mapped(images, scale);

    // 暂停计算
    thumbnails.pause();
    qDebug() << "isPaused" << thumbnails.isPaused();

    // 恢复计算
    if(thumbnails.isPaused()) {
        thumbnails.resume();
        qDebug() << "isStarted" << thumbnails.isPaused();
    }

    // 阻塞调用线程并等待计算完成，确保所有结果可用
    thumbnails.waitForFinished();

    // 返回 future 的所有结果
    QList list = thumbnails.results();
    foreach (QImage image, list) {
        qDebug() << image;
    }

    qDebug() << "********************";

    // 返回 future 的结果数
    int nCount = thumbnails.resultCount();
    for (int i = 0; i < nCount; ++i) {
        QImage image = thumbnails.resultAt(i);
        qDebug() << image;
    }

    return 0;
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• 51
• 52
• 53
• 54
• 55

为了演示效果，调用 mapped() 之后，使用 pause() 暂停计算，然后通过 isPaused() 来查询 QFuture 表示的计算状态。状态可以使用 isCanceled()、isStarted()、isFinished()、isRunning() 或 isPaused() 函数来查询。

注意：即使 isPaused() 返回 true，计算可能仍在运行。

要访问 future 中结果，可以使用索引位置。一些 QFuture 的成员函数将索引作为它们的第一个参数（例如：resultAt()），使得可以在不使用迭代器的情况下访问。

对于拥有多个结果的 QFuture 对象，resultCount() 函数返回连续结果的数量。这意味着，从 0 到 resultCount() 的结果始终是安全的。

迭代器

QFuture 提供了一个 Java 风格迭代器（QFutureIterator）和一个 STL 风格迭代器（QFuture::const_iterator）：

• Java 风格迭代器：高级、易于使用；但另一方面，效率略低。
• STL 风格迭代器：低级、使用麻烦；但另一方面，稍微更快。对于了解 STL 的人来说，可以很快上手。

使用这些迭代器是访问 future 中的结果的另一种方法。

QFutureIterator

QFutureIterator 类为 QFuture 提供了一个 Java 风格的 const 迭代器。

QFutureIterator  允许遍历 QFuture 。 注意：对于 QFuture，没有可变迭代器（不像其他的 Java 风格迭代器）。

QFutureIterator 构造函数使用 QFuture 作为其参数。在构造之后，迭代器位于结果列表的最开始（即：在第一个结果之前）。 以下是按顺序遍历所有结果的方法：

QFuture future;
...
QFutureIterator i(future);
while (i.hasNext())
    qDebug() << i.next();

• 1
• 2
• 3
• 4
• 5

next() 函数从 future 返回下一个结果（如果需要，等待它变得可用） 并推进迭代器。与 STL 风格迭代器不同，Java 风格迭代器指向结果之间，而不是直接指向结果。第一次调用 next() 将迭代器推进到第一个和第二个结果之间的位置，并返回第一个结果；第二次调用 next() 将迭代器推进到第二和第三个结果之间的位置，并返回第二个结果；以此类推。

下面是如何在相反的顺序遍历的元素：

QFutureIterator i(future);
i.toBack();
while (i.hasPrevious())
    qDebug() << i.previous();

• 1
• 2
• 3
• 4

如果要查找特定值的所有出现，可以在循环中使用 findNext() 或 findPrevious()。

可以在同一个 future 中使用多个迭代器，如果 future 在 QFutureIterator 处于活动状态时被修改，QFutureIterator 将继续迭代原始的 future，忽略修改的副本。

QFuture::const_iterator

QFuture :: const_iterator 类为 QFuture 提供了一个 STL 风格的 const 迭代器。

默认的 QFuture::const_iterator 构造函数会创建一个未初始化的迭代器。在开始迭代之前，必须使用 QFuture::constBegin() 或 QFuture::constEnd() 等 QFuture 函数进行初始化。

这是一个打印所有 QFuture 中可用的结果的典型循环：

QFuture future = ...;

QFuture::const_iterator i;
for (i = future.constBegin(); i != future.constEnd(); ++i)
    cout << *i << endl;

• 1
• 2
• 3
• 4
• 5

更多参考

• Qt之Concurrent框架
• Qt之Concurrent Map和Map-Reduce
• Qt之Concurrent Filter和Filter-Reduce
• Qt之Concurrent Run
• Qt之QFutureWatcher