簡述

QtConcurrent::map()、QtConcurrent::mapped() 和 QtConcurrent::mappedReduced() 函式對一個序列中（例如：QList、QVector）的專案並行地進行計算。QtConcurrent::map() 就地修改一個序列，QtConcurrent::mapped() 返回一個包含修改內容的新序列，QtConcurrent::mappedReduced() 返回一個單一的結果。

上述的每個函式都有一個 blocking 變數，其返回的是最終結果，而不是一個 QFuture。可以用和非同步變數同樣的方式來使用它們。

QList<QImage> images = ...
 
;

// 每次呼叫都會被阻塞，直到整個操作完成
QList<QImage> future = QtConcurrent::blockingMapped(images, scaled);

QtConcurrent::blockingMap(images, scale);

QImage collage = QtConcurrent::blockingMappedReduced(images, scaled, addToCollage);

注意：上述的結果型別不是 QFuture 物件，而是實際結果型別（在這種情況下，是 QList<QImage>和 QImage）。

|

Concurrent Map

QtConcurrent::mapped() 接受一個輸入序列和一個 map 函式，該 map 函式被序列中的每一項呼叫，並返回一個包含 map 函式返回值的新序列。

map 函式必須是以下形式：

U function(const T &t);

T 和 U 可以是任意型別（它們甚至可以是同一型別），但是 T 必須匹配儲存在序列中的型別，該函式返回修改或對映的內容。

下面示例，介紹瞭如何為序列中的每一項應用一個 scale 函式：

QImage scaled(const QImage &image)
{
    return image.scaled(100
 
, 100);
}

QList<QImage> images = ...;
QFuture<QImage> thumbnails = QtConcurrent::mapped(images, scaled);

map 的結果通過 QFuture 提供。有關如何在應用程式中使用 QFuture 的更多資訊，請參閱 QFuture 和 QFutureWatcher 文件。

如果想就地修改一個序列，使用 QtConcurrent::map()。map 函式必須是以下形式：

U function(T &t);

注意： map 函式的返回值、返回型別沒有被使用。

使用 QtConcurrent::map() 和使用 QtConcurrent::mapped() 類似：

void scale(QImage &image)
{
    image = image.scaled(100, 100);
}

QList<QImage> images = ...;
QFuture<void> future = QtConcurrent::map(images, scale);

由於該序列被就地修改，QtConcurrent::map() 不通過 QFuture 返回任何結果。然而，仍然可以使用 QFuture 和 QFutureWatcher 監控 map 的狀態。

Concurrent Map-Reduce

QtConcurrent::mappedReduced() 類似於 QtConcurrent::mapped()，但是不是返回具有新結果的序列，而是使用 reduce 函式將結果組合成單個值。

reduce 函式必須是以下形式：

V function(T &result, const U &intermediate)

T 是最終結果的型別，U 是 map 函式的返回型別。注意： reduce 函式的返回值、返回型別沒有被使用。

呼叫 QtConcurrent::mappedReduced() 如下所示：

void addToCollage(QImage &collage, const QImage &thumbnail)
{
    QPainter p(&collage);
    static QPoint offset = QPoint(0, 0);
    p.drawImage(offset, thumbnail);
    offset += ...;
}

QList<QImage> images = ...;
QFuture<QImage> collage = QtConcurrent::mappedReduced(images, scaled, addToCollage);

對於 map 函式返回的每個結果，reduce 函式將被呼叫一次，並且應該將中間體合併到結果變數中。QtConcurrent::mappedReduced() 保證一次只有一個執行緒呼叫 reduce，所以沒有必要用一個 mutex 鎖定結果變數。QtConcurrent::ReduceOptions 列舉提供了一種方法來控制 reduction 完成的順序。如果使用 QtConcurrent::UnorderedReduce（預設），順序是不確定的；而 QtConcurrent::OrderedReduce 確保 reduction 按照原始序列的順序完成。

附加 API 功能

使用迭代器而不是序列

上述每個函式都有一個變數，需要一個迭代器範圍，而不是一個序列。可以用和序列變數同樣的方式來使用它們。

QList<QImage> images = ...;

QFuture<QImage> thumbnails = QtConcurrent::mapped(images.constBegin(), images.constEnd(), scaled);

// map 僅就地執行在 non-const 迭代器上
QFuture<void> future = QtConcurrent::map(images.begin(), images.end(), scale);

QFuture<QImage> collage = QtConcurrent::mappedReduced(images.constBegin(), images.constEnd(), scaled, addToCollage);

Blocking 變數

上述每個函式能有一個 blocking 變數，其返回的是最終結果，而不是一個 QFuture。可以用和非同步變數同樣的方式來使用它們。

QList<QImage> images = ...;

// 每次呼叫都會被阻塞，直到整個操作完成
QList<QImage> future = QtConcurrent::blockingMapped(images, scaled);

QtConcurrent::blockingMap(images, scale);

QImage collage = QtConcurrent::blockingMappedReduced(images, scaled, addToCollage);

注意：上述的結果型別不是 QFuture 物件，而是實際結果型別（在這種情況下，是 QList<QImage>和 QImage）。

使用成員函式

QtConcurrent::map()、QtConcurrent::mapped() 和 QtConcurrent::mappedReduced() 接受成員函式的指標，成員函式類型別必須與儲存在序列中的型別匹配：

// 擠壓 QStringList 中的所有字串
QStringList strings = ...;
QFuture<void> squeezedStrings = QtConcurrent::map(strings, &QString::squeeze);

// 交換 images 列表中圖片所有畫素的 rgb 值
QList<QImage> images = ...;
QFuture<QImage> bgrImages = QtConcurrent::mapped(images, &QImage::rgbSwapped);

// 建立一個列表中所有字串長度的集合  
QStringList strings = ...;
QFuture<QSet<int> > wordLengths = QtConcurrent::mappedReduced(strings, &QString::length, &QSet<int>::insert);

注意：當使用 QtConcurrent::mappedReduced() 時，可以自由地混合使用正常函式和成員函式：

// 可以使用 QtConcurrent::mappedReduced() 混合正常函式和成員函式

// 計算字串列表的平均長度
extern void computeAverage(int &average, int length);
QStringList strings = ...;
QFuture<int> averageWordLength = QtConcurrent::mappedReduced(strings, &QString::length, computeAverage);

// 建立一個列表中所有影象顏色分佈的集合
extern int colorDistribution(const QImage &string);
QList<QImage> images = ...;
QFuture<QSet<int> > totalColorDistribution = QtConcurrent::mappedReduced(images, colorDistribution, QSet<int>::insert);

使用函式物件

QtConcurrent::map()、QtConcurrent::mapped() 和 QtConcurrent::mappedReduced() 接受函式物件，可用於向函式呼叫新增狀態。result_type typedef 必須定義結果函式呼叫操作符的型別：

struct Scaled
{
    Scaled(int size)
    : m_size(size) { }

    typedef QImage result_type;

    QImage operator()(const QImage &image)
    {
        return image.scaled(m_size, m_size);
    }

    int m_size;
};

QList<QImage> images = ...;
QFuture<QImage> thumbnails = QtConcurrent::mapped(images, Scaled(100));

使用繫結函式引數

如果想使用一個接受多個引數的 map 函式，可以使用 std::bind() 將其轉換到接受一個引數的函式。如果 C++11 支援不可用，boost::bind() 或 std::tr1::bind() 是合適的替代品。

例如，使用 QImage::scaledToWidth()：

QImage QImage::scaledToWidth(int width, Qt::TransformationMode) const;

scaledToWidth 接收三個引數（包括“this”指標），不能直接使用 QtConcurrent::mapped()，因為 QtConcurrent::mapped() 期望一個接收一個引數的函式。為了 QImage::scaledToWidth() 和 QtConcurrent::mapped() 一起使用，必須為 width 和 transformation mode 提供一個值：

std::bind(&QImage::scaledToWidth, 100, Qt::SmoothTransformation)

std::bind() 的返回值是一個具有以下簽名的函式物件（functor）：

QImage scaledToWith(const QImage &image)

這符合 QtConcurrent::mapped() 期望的，完整的示例變為：

QList<QImage> images = ...;
QFuture<QImage> thumbnails = QtConcurrent::mapped(images, std::bind(&QImage::scaledToWidth, 100 Qt::SmoothTransformation));

更多參考