Parallele Aufgabe

QtConcurrent::task bietet eine alternative Schnittstelle zum Ausführen einer Aufgabe in einem separaten Thread. Der Rückgabewert der Funktion wird über die API „ QFuture “ bereitgestellt.

Wenn Sie lediglich eine Funktion in einem separaten Thread ausführen möchten, ohne Parameter anzupassen, verwenden Sie „ QtConcurrent::run “, da Sie so weniger Code schreiben müssen. Die Funktion „ QtConcurrent::task “ ist für Fälle vorgesehen, in denen zusätzliche Konfigurationsschritte erforderlich sind.

Diese Funktion ist Teil des Qt Concurrent Frameworks.

Optimieren der Einbindungen

Wenn Sie den Header „ <QtConcurrent> “ einbinden, wird das gesamte Modul „ Qt Concurrent “ zusammen mit dem gesamten Modul „ Qt Core “ eingebunden, was die Kompilierungszeiten und die Größe der Binärdateien erhöhen kann. Um die Funktion „ QtConcurrent::task()“ zu verwenden, können Sie einen spezifischeren Header einbinden:

#include <QtConcurrentTask>

Fluent-Schnittstelle

Die Funktion ` QtConcurrent::task ` gibt eine Instanz einer Hilfsklasse namens ` QtConcurrent::QTaskBuilder` zurück. Normalerweise müssen Sie keine Instanz dieser Klasse manuell erstellen. Die Funktion ` QtConcurrent::QTaskBuilder ` bietet eine Schnittstelle, um verschiedene Aufgabenparameter kettenartig anzupassen. Dieser Ansatz wird als „Fluent Interface“ bezeichnet.

Sie können einfach die benötigten Parameter festlegen und anschließend eine Aufgabe starten. Um die Konfiguration einer Aufgabe abzuschließen, müssen Sie ` QtConcurrent::QTaskBuilder::spawn` aufrufen. Diese Funktion ist nicht blockierend (d. h., sie gibt sofort ein Future-Objekt zurück), es ist jedoch nicht garantiert, dass die Aufgabe sofort startet. Mit den Klassen „ QFuture “ und „ QFutureWatcher “ können Sie den Status der Aufgabe überwachen.

Weitere Beispiele und Erläuterungen finden Sie weiter unten.

Ausführen einer Aufgabe in einem separaten Thread

Um eine Funktion in einem anderen Thread auszuführen, verwenden Sie „ QtConcurrent::QTaskBuilder::spawn “:

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

Dadurch wird eine Lambda-Funktion in einem separaten Thread ausgeführt, der vom Standard- QThreadPool bereitgestellt wird.

Argumente an die Aufgabe übergeben

Der Aufruf einer Funktion mit Argumenten erfolgt durch deren Übergabe an ` QtConcurrent::QTaskBuilder::withArguments`:

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

An der Stelle, an der ` QtConcurrent::QTaskBuilder::withArguments ` aufgerufen wird, wird von jedem Argument eine Kopie erstellt, und diese Werte werden an den Thread übergeben, sobald dieser mit der Ausführung der Aufgabe beginnt. Änderungen, die nach dem Aufruf von ` QtConcurrent::QTaskBuilder::withArguments ` an den Argumenten vorgenommen werden, sind für den Thread nicht sichtbar.

Wenn Sie eine Funktion ausführen möchten, die Argumente per Referenz entgegennimmt, sollten Sie die Hilfsfunktionen `std::ref`/`cref` verwenden. Diese Funktionen erstellen „dünne“ Wrapper um die übergebenen Argumente:

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

Stellen Sie sicher, dass alle umhüllten Objekte lange genug bestehen bleiben. Es kann zu undefiniertem Verhalten kommen, wenn eine Aufgabe länger besteht als das durch std::ref/cref umhüllte Objekt.

Rückgabewerte der Aufgabe

Sie können das Ergebnis einer Aufgabe mit der API „ QFuture “ abrufen:

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

Beachten Sie, dass ` QFuture::result()` ein blockierender Aufruf ist, der wartet, bis das Ergebnis verfügbar ist. Verwenden Sie ` QFutureWatcher `, um eine Benachrichtigung zu erhalten, wenn die Aufgabe ihre Ausführung beendet hat und das Ergebnis verfügbar ist.

Falls Sie ein Ergebnis an eine andere asynchrone Aufgabe übergeben möchten, können Sie mit ` QFuture::then()` eine Kette abhängiger Aufgaben erstellen. Weitere Details finden Sie in der Dokumentation zu ` QFuture `.

Zusätzliche API-Funktionen

Verwendung verschiedener Arten von aufrufbaren Objekten

Genau genommen können Sie jeden Task- und Argumenttyp verwenden, der die folgende Bedingung erfüllt:

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

Sie können eine freie Funktion verwenden:

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

Sie können eine Member-Funktion verwenden:

QString result("Hello, world!");

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

Sie können ein aufrufbares Objekt mit einem operator() verwenden:

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

Wenn Sie ein vorhandenes aufrufbares Objekt verwenden möchten, müssen Sie es entweder nach ` QtConcurrent::task ` kopieren/verschieben oder es mit `std::ref`/`cref` umschließen:

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

Verwendung eines benutzerdefinierten Thread-Pools

Sie können einen benutzerdefinierten Thread-Pool angeben:

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

Priorität für eine Aufgabe festlegen

Sie können die Priorität für eine Aufgabe festlegen:

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

Wenn Sie kein Future-Objekt benötigen, können Sie ` QtConcurrent::QTaskBuilder::spawn` (QtConcurrent::FutureResult::Ignore) aufrufen:

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

Sie können auf das mit der Aufgabe verknüpfte Promise-Objekt zugreifen, indem Sie innerhalb der Funktion ein zusätzliches Argument vom Typ „ QPromise<T> & “ definieren. Dieses zusätzliche Argument muss das erste an die Funktion übergebene Argument sein, und wie im Modus „Concurrent Run With Promise“ wird erwartet, dass die Funktion den Typ „void“ zurückgibt. Die Ergebnisausgabe erfolgt über die „ QPromise “-API:

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

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