En esta página

Map y Map-Reduce concurrentes

Las funciones QtConcurrent::map(), QtConcurrent::mapped() y QtConcurrent::mappedReduced() ejecutan cálculos en paralelo sobre los elementos de una secuencia, como, por ejemplo, un QList. QtConcurrent::map() modifica una secuencia in situ, QtConcurrent::mapped() devuelve una nueva secuencia que contiene el contenido modificado y QtConcurrent::mappedReduced() devuelve un único resultado.

Estas funciones forman parte del Qt Concurrent marco de trabajo.

Cada una de las funciones anteriores tiene una variante bloqueante que devuelve el resultado final en lugar de un ` QFuture`. Se utilizan de la misma manera que las variantes asíncronas.

QList<QImage> images = ...;

// Each call blocks until the entire operation is finished.
QList<QImage> future = QtConcurrent::blockingMapped(images, scaled);

QtConcurrent::blockingMap(images, scale);

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

Ten en cuenta que los tipos de resultado anteriores no son objetos ` QFuture `, sino tipos de resultado reales (en este caso, ` QList` <QImage> y `QImage`).

Optimizar las inclusiones

Si se incluye el encabezado <QtConcurrent>, se incluirá todo el módulo Qt Concurrent junto con todo el módulo Qt Core, lo que puede aumentar los tiempos de compilación y el tamaño de los binarios. Para utilizar las funciones QtConcurrent::map(), QtConcurrent::mapped() y QtConcurrent::mappedReduced(), se puede incluir un encabezado más específico:

#include <QtConcurrentMap>

Mapa concurrente

QtConcurrent::mapped() toma una secuencia de entrada y una función de aplicación. A continuación, esta función de aplicación se invoca para cada elemento de la secuencia, y se devuelve una nueva secuencia que contiene los valores devueltos por la función de aplicación.

La función «map» debe tener la siguiente forma:

U function(const T &t);

T y U pueden ser de cualquier tipo (e incluso pueden ser del mismo tipo), pero T debe coincidir con el tipo almacenado en la secuencia. La función devuelve el contenido modificado o mapeado.

Este ejemplo muestra cómo aplicar una función de escala a todos los elementos de una secuencia:

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

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

Los resultados de la aplicación de la función se pueden consultar a través de QFuture. Consulta la documentación de QFuture y QFutureWatcher para obtener más información sobre cómo utilizar QFuture en tus aplicaciones.

Si desea modificar una secuencia in situ, utilice QtConcurrent::map(). En ese caso, la función map debe tener la siguiente forma:

U function(T &t);

Ten en cuenta que el valor de retorno y el tipo de retorno de la función map no se utilizan.

El uso de QtConcurrent::map() es similar al de QtConcurrent::mapped():

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

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

Dado que la secuencia se modifica in situ, QtConcurrent::map() no devuelve ningún resultado a través de QFuture. No obstante, se pueden seguir utilizando QFuture y QFutureWatcher para supervisar el estado de la aplicación de la función map.

Mapeado concurrente y continuaciones

El resultado de la llamada a QtConcurrent::mapped() es un QFuture que contiene varios resultados. Al asociar una continuación de tipo .then() a dicho QFuture, asegúrate de utilizar una continuación que tome QFuture como parámetro; de lo contrario, solo se procesará el primer resultado:

auto process = [](int val) {
    return val * 2;
};

QList<int> inputs { 1, 2, 3 };
auto badFuture = QtConcurrent::mapped(inputs, process)
                         .then([](int val) {
                             qDebug() << val;
                         });

auto goodFuture = QtConcurrent::mapped(inputs, process)
                          .then([](QFuture<int> f) {
                              for (auto r : f.results()) {
                                  qDebug() << r;
                              }
                          });

En este ejemplo, « badFuture » solo mostrará un único resultado, mientras que « goodFuture » mostrará todos los resultados.

Map-Reduce concurrente

QtConcurrent::mappedReduced() es similar a QtConcurrent::mapped(), pero en lugar de devolver una secuencia con los nuevos resultados, estos se combinan en un único valor mediante una función de reducción.

La función de reducción debe tener la siguiente forma:

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

T es el tipo del resultado final, U es el tipo de retorno de la función «map». Ten en cuenta que el valor de retorno y el tipo de retorno de la función «reduce» no se utilizan.

Llama a QtConcurrent::mappedReduced() de la siguiente manera:

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

La función `reduce` se llamará una vez por cada resultado devuelto por la función `map`, y debe fusionar el resultado intermedio en la variable `result`. QtConcurrent::mappedReduced() garantiza que solo un hilo llamará a `reduce` a la vez, por lo que no es necesario utilizar un mutex para bloquear la variable `result`. La enumeración « QtConcurrent::ReduceOptions » permite controlar el orden en el que se realiza la reducción. Si se utiliza « QtConcurrent::UnorderedReduce » (el valor por defecto), el orden es indefinido, mientras que « QtConcurrent::OrderedReduce » garantiza que la reducción se realice en el orden de la secuencia original.

Características adicionales de la API

Uso de iteradores en lugar de secuencias

Cada una de las funciones anteriores tiene una variante que admite un rango de iteradores en lugar de una secuencia. Se utilizan de la misma forma que las variantes de secuencia:

QList<QImage> images = ...;

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

// Map in-place only works on non-const iterators.
QFuture<void> future = QtConcurrent::map(images.begin(), images.end(), scale);

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

Variantes de bloqueo

Cada una de las funciones anteriores tiene una variante de bloqueo que devuelve el resultado final en lugar de un ` QFuture`. Se utilizan de la misma manera que las variantes asíncronas.

QList<QImage> images = ...;

// Each call blocks until the entire operation is finished.
QList<QImage> future = QtConcurrent::blockingMapped(images, scaled);

QtConcurrent::blockingMap(images, scale);

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

Tenga en cuenta que los tipos de resultado anteriores no son objetos de tipo « QFuture », sino tipos de resultado reales (en este caso, QList<QImage> y QImage).

Uso de funciones de miembro

QtConcurrent::map(), QtConcurrent::mapped() y QtConcurrent::mappedReduced() aceptan punteros a funciones miembro. El tipo de clase de la función miembro debe coincidir con el tipo almacenado en la secuencia:

// Comprimir todas las cadenas de una QStringList.
QStringList strings =...;
QFuture<void> squeezedStrings = QtConcurrent::map(strings, &QString::squeeze);

// Intercambia los valores RGB de todos los píxeles de una lista de imágenes.
QList<QImage> imágenes =...;
QFuture<QImage> bgrImages = QtConcurrent::mapped(images,
    static_cast<QImage (QImage::*)() const &>(&QImage::rgbSwapped));

// Crea un conjunto con las longitudes de todas las cadenas de una lista.
QStringList strings =...;
QFuture<QSet<int>> longitudesDePalabras = QtConcurrent::mappedReduced(strings, &QString::length,
                                                             qOverload<const int&>(&QSet<int>::insert));

Fíjate en el uso de « qOverload ». Es necesario para resolver la ambigüedad en los métodos que tienen varias sobrecargas.

Ten en cuenta también que, al utilizar QtConcurrent::mappedReduced(), puedes combinar libremente el uso de funciones normales y funciones miembro:

// Se pueden mezclar funciones normales y funciones miembro con QtConcurrent::mappedReduced().

// Calcular la longitud media de una lista de cadenas.
extern void computeAverage(int &average, int length);
QStringList strings =...;
QFuture<int> averageWordLength = QtConcurrent::mappedReduced(strings, &QString::length, computeAverage);

// Crear un conjunto con la distribución de colores de todas las imágenes de una lista.
extern int colorDistribution(const QImage &string);
QList<QImage> images =...;
QFuture<QSet<int>> distribuciónDeColoresTotal = QtConcurrent::mappedReduced(imágenes, distribuciónDeColores,
                                                                        qOverload<const int&>(&QSet<int>::insert));

Uso de objetos de función

QtConcurrent::map(), QtConcurrent::mapped() y QtConcurrent::mappedReduced() admiten objetos de función para la función map. Estos objetos de función se pueden utilizar para añadir estado a una llamada a función:

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

Los objetos de función también son compatibles con la función reduce:

struct ImageTransform
{
    void operator()(QImage &result, const QImage &value);
};

QFuture<QImage> thumbNails =
        QtConcurrent::mappedReduced(images, Scaled(100), ImageTransform(),
                                    QtConcurrent::SequentialReduce);

Uso de expresiones lambda

QtConcurrent::map(), QtConcurrent::mapped() y QtConcurrent::mappedReduced() admiten expresiones lambda para las funciones map y reduce:

QList<int> vector { 1, 2, 3, 4 };
QtConcurrent::blockingMap(vector, [](int &x) { x *= 2; });

int size = 100;
QList<QImage> images = ...;

QList<QImage> thumbnails = QtConcurrent::mapped(images,
        [&size](const QImage &image) {
            return image.scaled(size, size);
        }
    ).results();

Al utilizar QtConcurrent::mappedReduced() o QtConcurrent::blockingMappedReduced(), puedes combinar libremente el uso de funciones normales, funciones miembro y expresiones lambda.

QList<QImage> collage = QtConcurrent::mappedReduced(images,
        [&size](const QImage &image) {
            return image.scaled(size, size);
        },
        addToCollage
   ).results();

También se puede pasar una lambda como objeto de la función `reduce`:

QList<QImage> collage = QtConcurrent::mappedReduced(images,
        [&size](const QImage &image) {
            return image.scaled(size, size);
        },
        [](QImage &result, const QImage &value) {
            // do some transformation
        }
   ).results();

Envolver funciones que admiten varios argumentos

Si se desea utilizar una función «map» que admita más de un argumento, se puede recurrir a una función lambda o a un std::bind() o para transformarla en una función que admita un solo argumento.

A modo de ejemplo, utilizaremos QImage::scaledToWidth():

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

scaledToWidth toma tres argumentos (incluido el puntero «this») y no se puede utilizar directamente con QtConcurrent::mapped(), ya que esta última espera una función que tome un solo argumento. Para utilizar QImage::scaledToWidth() con QtConcurrent::mapped(), debemos proporcionar un valor para el ancho y el modo de transformación:

QList<QImage> images = ...;
std::function<QImage(const QImage &)> scale = [](const QImage &img) {
    return img.scaledToWidth(100, Qt::SmoothTransformation);
};
QFuture<QImage> thumbnails = QtConcurrent::mapped(images, scale);

© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.