Qt之QFuture

简述

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

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

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

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

  • 简述
  • 基本使用
  • 高级操作
  • 迭代器
    • QFutureIterator
    • QFutureconst_iterator
  • 更多参考

基本使用

要在另一个线程中运行函数,使用 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() 将迭代器推进到第二和第三个结果之间的位置,并返回第二个结果;以此类推。

Qt之QFuture_第1张图片

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

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

你可能感兴趣的:(Qt,C/C++)