Tarea Concurrente

QtConcurrent::task proporciona una interfaz alternativa para ejecutar una tarea en un hilo separado. El valor de retorno de la función está disponible a través de la API QFuture.

Si sólo desea ejecutar una función en un hilo separado sin ajustar ningún parámetro, utilice QtConcurrent::run ya que le permite escribir menos código. La QtConcurrent::task está diseñada para casos en los que es necesario realizar pasos de configuración adicionales.

Esta función forma parte del Qt Concurrent framework.

Optimizar includes

Si incluyes la cabecera <QtConcurrent>, se incluirá todo el módulo Qt Concurrent 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 la función QtConcurrent::task(), puede incluir una cabecera más específica:

#include <QtConcurrentTask>

Interfaz fluida

QtConcurrent::task devuelve una instancia de una clase auxiliar llamada QtConcurrent::QTaskBuilder. Normalmente, no es necesario crear una instancia de esta clase manualmente. El QtConcurrent::QTaskBuilder proporciona una interfaz para ajustar diferentes parámetros de la tarea de forma encadenada. Este enfoque se conoce como interfaz fluida.

Sólo tienes que establecer los parámetros que necesitas y luego poner en marcha una tarea. Para finalizar la configuración de una tarea debe invocar QtConcurrent::QTaskBuilder::spawn. Esta función es no-bloqueante (es decir, devuelve un objeto futuro inmediatamente), pero no está garantizado que la tarea se inicie inmediatamente. Puede utilizar las clases QFuture y QFutureWatcher para controlar el estado de la tarea.

Ver más ejemplos y explicaciones a continuación.

Ejecutar una tarea en un subproceso distinto

Para ejecutar una función en otro hilo, utilice QtConcurrent::QTaskBuilder::spawn:

QtConcurrent::task([]{ qDebug("Hello, world!"); }).spawn();

Esto ejecutará una función lambda en un hilo separado obtenido del hilo por defecto QThreadPool.

Pasar argumentos a la tarea

La invocación de una función con argumentos se realiza pasándolos a QtConcurrent::QTaskBuilder::withArguments:

auto task = [](const QString &s){ qDebug() << ("Hello, " + s); };
QtConcurrent::task(std::move(task))
    .withArguments("world!")
    .spawn();

Se hace una copia de cada argumento en el punto donde se llama a QtConcurrent::QTaskBuilder::withArguments, y estos valores se pasan al hilo cuando comienza a ejecutar la tarea. Los cambios realizados en los argumentos después de llamar a QtConcurrent::QTaskBuilder::withArguments no son visibles para el subproceso.

Si desea ejecutar una función que acepta argumentos por referencia, debe utilizar las funciones auxiliares std::ref/cref. Estas funciones crean finas envolturas alrededor de los argumentos pasados:

QString s("Hello, ");
QtConcurrent::task([](QString &s){ s.append("world!"); })
    .withArguments(std::ref(s))
    .spawn();

Asegúrese de que todos los objetos envueltos viven lo suficiente. Es posible obtener un comportamiento indefinido si una tarea sobrevive al objeto envuelto por std::ref/cref.

Devolución de valores de la tarea

Puede obtener el resultado de una tarea con la API QFuture:

auto future = QtConcurrent::task([]{ return 42; }).spawn();
auto result = future.result(); // result == 42

Tenga en cuenta que QFuture::result() es una llamada de bloqueo, espera a que el resultado esté disponible. Utilice QFutureWatcher para obtener una notificación cuando la tarea haya finalizado su ejecución y el resultado esté disponible.

En caso de que quieras pasar un resultado a otra tarea asíncrona, puedes utilizar QFuture::then() para crear una cadena de tareas dependientes. Consulte la documentación de QFuture para obtener más detalles.

Funciones adicionales de la API

Uso de distintos tipos de objetos invocables

Estrictamente hablando, puede utilizar cualquier tipo de tareas y argumentos que cumplan la siguiente condición:

std::is_invocable_v<std::decay_t<Task>, std::decay_t<Args>...>

Puede utilizar una función libre:

QVariant value(42);
auto result = QtConcurrent::task([](const QVariant &var){return qvariant_cast<int>(var);})
                  .withArguments(value)
                  .spawn()
                  .result(); // result == 42

Puede utilizar una función miembro:

QString result("Hello, world!");

QtConcurrent::task(&QString::chop)
    .withArguments(&result, 8)
    .spawn()
    .waitForFinished(); // result == "Hello"

Puede utilizar un objeto invocable con un operador():

auto result = QtConcurrent::task(std::plus<int>())
                  .withArguments(40, 2)
                  .spawn()
                  .result() // result == 42

Si quieres usar un objeto callable existente, necesitas copiarlo/moverlo a QtConcurrent::task o envolverlo con std::ref/cref:

struct CallableWithState
{
    void operator()(int newState) { state = newState; }

    // ...
};

// ...

CallableWithState object;

QtConcurrent::task(std::ref(object))
   .withArguments(42)
   .spawn()
   .waitForFinished(); // The object's state is set to 42

Uso de un grupo de hilos personalizado

Puede especificar un grupo de hilos personalizado:

QThreadPool pool;
QtConcurrent::task([]{ return 42; }).onThreadPool(pool).spawn();

Establecer la prioridad de una tarea

Puede establecer la prioridad de una tarea:

QtConcurrent::task([]{ return 42; }).withPriority(10).spawn();

Si no necesitas un objeto futuro, puedes llamar a QtConcurrent::QTaskBuilder::spawn(QtConcurrent::FutureResult::Ignore):

QtConcurrent::task([]{ qDebug("Hello, world!"); }).spawn(FutureResult::Ignore);

Puedes acceder al objeto promesa asociado a la tarea definiendo un argumento adicional de tipo QPromise<T> & dentro de la función. Este argumento adicional debe ser el primer argumento pasado a la función, y al igual que en el modo Concurrent Run With Promise, se espera que la función devuelva tipo void. La notificación de resultados se realiza a través de la API QPromise:

void increment(QPromise<int> &promise, int i)
{
    promise.addResult(i + 1);
}

int result = QtConcurrent::task(&increment).withArguments(10).spawn().result(); // result == 11