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

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

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

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

基本使用

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

#include <QCoreApplication>
#include <QtConcurrent/QtConcurrentRun>
#include <QDebug>

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

这时，输出如下：

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

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

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

高级操作

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 <QImage>
#include <QDebug>
#include <QGuiApplication>
#include <QtConcurrent/QtConcurrentMap>

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<QImage> images;
    for (int i = 0; i < imageCount; ++i)
        images.append(QImage(1600, 1200, QImage::Format_ARGB32_Premultiplied));

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

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

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

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

    // 返回 future 的所有结果
    QList<QImage> 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;
}

为了演示效果，调用 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 <T> 允许遍历 QFuture <T> 。 注意： 对于 QFuture，没有可变迭代器（不像其他的 Java 风格迭代器）。

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

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

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

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

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

如果要查找特定值的所有出现，可以在循环中使用 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<QString> future = ...;

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

更多参考

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

 

标签：const,Qt,迭代,结果,future,QFutureIterator,QFuture
来源： https://blog.csdn.net/weixin_38293850/article/details/120891481