QFuture Class

Dokumentation der Mitgliedsfunktionen

QFuture::QFuture()

Konstruiert eine leere, abgebrochene Zukunft.

QFuture::QFuture(const QFuture<T> &other)

Konstruiert eine Kopie von other.

Siehe auch operator=().

QFuture::~QFuture()

Zerstört den Future.

Beachten Sie, dass dadurch die asynchrone Berechnung weder abgewartet noch abgebrochen wird. Verwenden Sie waitForFinished() oder QFutureSynchronizer, wenn Sie sicherstellen müssen, dass die Berechnung abgeschlossen ist, bevor der Future zerstört wird.

template <typename U = T, typename = QtPrivate::EnableForNonVoid<U>> QFuture<T>::const_iterator QFuture::begin() const

Gibt einen const STL-artigen Iterator zurück, der auf das erste Ergebnis in der Zukunft zeigt.

Siehe auch constBegin() und end().

void QFuture::cancel()

Bricht die durch diesen Future dargestellte asynchrone Berechnung ab. Beachten Sie, dass der Abbruch asynchron erfolgt. Verwenden Sie waitForFinished() nach dem Aufruf von cancel(), wenn Sie einen synchronen Abbruch benötigen.

Auf aktuell verfügbare Ergebnisse kann weiterhin über einen abgebrochenen Future zugegriffen werden, aber neue Ergebnisse werden nach dem Aufruf dieser Funktion nicht mehr verfügbar. Jedes QFutureWatcher Objekt, das diesen Future beobachtet, wird bei einem abgebrochenen Future keine Fortschritts- und Ergebnisbereitschaftssignale liefern.

Beachten Sie, dass nicht alle laufenden asynchronen Berechnungen abgebrochen werden können. Zum Beispiel kann der von QtConcurrent::run() zurückgegebene Future nicht abgebrochen werden, aber der von QtConcurrent::mappedReduced() zurückgegebene Future schon.

template <typename U = T, typename = QtPrivate::EnableForNonVoid<U>> QFuture<T>::const_iterator QFuture::constBegin() const

Gibt einen const STL-artigen Iterator zurück, der auf das erste Ergebnis in der Zukunft zeigt.

Siehe auch begin() und constEnd().

template <typename U = T, typename = QtPrivate::EnableForNonVoid<U>> QFuture<T>::const_iterator QFuture::constEnd() const

Gibt einen const STL-artigen Iterator zurück, der auf das imaginäre Ergebnis nach dem letzten Ergebnis in der Zukunft zeigt.

Siehe auch constBegin() und end().

template <typename U = T, typename = QtPrivate::EnableForNonVoid<U>> QFuture<T>::const_iterator QFuture::end() const

Gibt einen const STL-artigen Iterator zurück, der auf das imaginäre Ergebnis nach dem letzten Ergebnis in der Zukunft zeigt.

Siehe auch begin() und constEnd().

bool QFuture::isCanceled() const

Gibt true zurück, wenn die asynchrone Berechnung mit der Funktion cancel() abgebrochen wurde; andernfalls wird false zurückgegeben.

Beachten Sie, dass die Berechnung noch laufen kann, obwohl diese Funktion true zurückgibt. Siehe cancel() für weitere Details.

bool QFuture::isFinished() const

Gibt true zurück, wenn die asynchrone Berechnung, die durch diesen future repräsentiert wird, beendet ist; andernfalls wird false zurückgegeben.

template <typename U = T, typename = QtPrivate::EnableForNonVoid<U>> bool QFuture::isResultReadyAt(int index) const

Gibt true zurück, wenn das Ergebnis unter index sofort verfügbar ist; andernfalls wird false zurückgegeben.

Siehe auch resultAt(), resultCount(), und takeResult().

bool QFuture::isRunning() const

Gibt true zurück, wenn die asynchrone Berechnung, die durch diesen future repräsentiert wird, gerade läuft; andernfalls wird false zurückgegeben.

bool QFuture::isStarted() const

Gibt true zurück, wenn die asynchrone Berechnung, die durch diesen future repräsentiert wird, gestartet wurde; andernfalls wird false zurückgegeben.

[since 6.0] bool QFuture::isSuspended() const

Gibt true zurück, wenn eine Unterbrechung der asynchronen Berechnung angefordert wurde und diese in Kraft ist, was bedeutet, dass keine weiteren Ergebnisse oder Fortschrittsänderungen erwartet werden.

Diese Funktion wurde in Qt 6.0 eingeführt.

Siehe auch setSuspended(), toggleSuspended(), und isSuspending().

[since 6.0] bool QFuture::isSuspending() const

Gibt true zurück, wenn die asynchrone Berechnung mit der Funktion suspend() unterbrochen wurde, die Arbeit aber noch nicht unterbrochen ist und die Berechnung noch läuft. Andernfalls wird false zurückgegeben.

Um zu prüfen, ob die Unterbrechung tatsächlich in Kraft ist, verwenden Sie stattdessen isSuspended().

Diese Funktion wurde in Qt 6.0 eingeführt.

Siehe auch setSuspended(), toggleSuspended(), und isSuspended().

[since 6.0] bool QFuture::isValid() const

Gibt true zurück, wenn ein Ergebnis oder Ergebnisse von diesem QFuture Objekt abgerufen oder entnommen werden können. Gibt false zurück, wenn das Ergebnis aus dem future entnommen wurde.

Diese Funktion wurde in Qt 6.0 eingeführt.

Siehe auch takeResult(), result(), results(), und resultAt().

[since 6.0] template <typename Function, typename = std::enable_if_t<std::is_invocable_r_v<T, Function>>> QFuture<T> QFuture::onCanceled(Function &&handler)

Hängt eine Stornierung handler an diesen Future an. Der zurückgegebene Future verhält sich genau wie dieser Future (hat denselben Zustand und dasselbe Ergebnis), es sei denn, dieser Future wird abgebrochen. handler ist eine aufrufbare Variable, die keine Argumente annimmt und einen Wert des Typs zurückgibt, der von diesem Future verpackt wurde. Nach dem Abbruch verpackt der zurückgegebene Future den von handler zurückgegebenen Wert.

Wenn er vor dem Abbruch angehängt wird, wird handler in demselben Thread aufgerufen, der den Future nach dem Abbruch als beendet meldet. Wenn der Handler angehängt wird, nachdem dieser Future bereits abgebrochen wurde, wird er sofort in dem Thread aufgerufen, der onCanceled() ausführt. Daher kann der Handler nicht immer Annahmen darüber treffen, in welchem Thread er ausgeführt werden soll. Verwenden Sie die Überladung, die ein Kontextobjekt annimmt, wenn Sie steuern möchten, in welchem Thread der Handler aufgerufen wird.

Das folgende Beispiel zeigt, wie man einen Abbruch-Handler anfügt:

QFuture<int> testFuture = ...;
auto resultFuture = testFuture.then([](int res) {
    // Block 1
    ...
    return 1;
}).then([](int res) {
    // Block 2
    ...
    return 2;
}).onCanceled([] {
    // Block 3
    ...
    return -1;
});

Wenn testFuture abgebrochen wird, wird Block 3 aufgerufen und resultFuture hat -1 als Ergebnis. Im Gegensatz zu testFuture befindet es sich nicht im Zustand Canceled. Das bedeutet, dass Sie sein Ergebnis abrufen, ihm Zählungen zuordnen können usw.

Beachten Sie auch, dass Sie die Kette der Fortsetzungen während ihrer Ausführung über den Future, der die Kette gestartet hat, abbrechen können. Angenommen, testFuture.cancel() wurde aufgerufen, während Block 1 bereits ausgeführt wird. Die nächste Fortsetzung wird erkennen, dass ein Abbruch angefordert wurde, so dass Block 2 übersprungen und der Abbruchhandler (Block 3) aufgerufen wird.

Diese Funktion wurde in Qt 6.0 eingeführt.

Siehe auch then() und onFailed().

[since 6.1] template <typename Function, typename = std::enable_if_t<std::is_invocable_r_v<T, Function>>> QFuture<T> QFuture::onCanceled(QObject *context, Function &&handler)

Dies ist eine überladene Funktion.

Hängt an diesen Future eine Stornierung handler an, die aufgerufen wird, wenn der Future storniert wird. Die handler ist eine Callable, die keine Argumente entgegennimmt. Sie wird im Thread des context Objekts aufgerufen. Dies kann nützlich sein, wenn die Stornierung in einem bestimmten Thread behandelt werden muss.

Wenn context zerstört wird, bevor die Kette beendet ist, wird der Future abgebrochen. Siehe then() für Details.

Siehe die Dokumentation der anderen Überladung für weitere Details über handler.

Diese Funktion wurde in Qt 6.1 eingeführt.

Siehe auch then() und onFailed().

[since 6.0] template <typename Function, typename = std::enable_if_t<!QtPrivate::ArgResolver<Function>::HasExtraArgs>> QFuture<T> QFuture::onFailed(Function &&handler)

Hängt einen Fehlerbehandler an diesen Future an, um eventuelle Ausnahmen zu behandeln. Der zurückgegebene Future verhält sich genau wie dieser Future (hat denselben Zustand und dasselbe Ergebnis), es sei denn, dieser Future schlägt mit einer Ausnahme fehl.

handler ist eine Callable, die entweder kein Argument oder ein Argument entgegennimmt, um nach bestimmten Fehlertypen zu filtern, ähnlich wie die catch-Anweisung. Sie gibt einen Wert des Typs zurück, der von diesem Future verpackt wurde. Nach dem Fehler verpackt der zurückgegebene Future den von handler zurückgegebenen Wert.

Der Handler wird nur aufgerufen, wenn eine Ausnahme ausgelöst wird. Wenn die Ausnahme ausgelöst wird, nachdem dieser Handler angehängt wurde, wird der Handler in dem Thread ausgeführt, der den Future als Ergebnis der Ausnahme als beendet meldet. Wenn der Handler angehängt wird, nachdem dieser Future bereits fehlgeschlagen ist, wird er sofort in dem Thread aufgerufen, der onFailed() ausführt. Daher kann der Handler nicht immer Annahmen darüber treffen, in welchem Thread er ausgeführt werden soll. Verwenden Sie die Überladung, die ein Kontextobjekt annimmt, wenn Sie steuern möchten, in welchem Thread der Handler aufgerufen wird.

Das folgende Beispiel zeigt, wie ein Fehler-Handler angehängt werden kann:

QFuture<int> future = ...;
auto resultFuture = future.then([](int res) {
    ...
    throw Error();
    ...
}).onFailed([](const Error &e) {
    // Handle exceptions of type Error
    ...
    return -1;
}).onFailed([] {
    // Handle all other types of errors
    ...
    return -1;
});

auto result = resultFuture.result(); // result is -1

Wenn mehrere Handler angehängt sind, wird der erste Handler, der mit dem Typ der ausgelösten Ausnahme übereinstimmt, aufgerufen. Ein Beispiel:

QFuture<int> future = ...;
future.then([](int res) {
    ...
    throw std::runtime_error("message");
    ...
}).onFailed([](const std::exception &e) {
    // This handler will be invoked
}).onFailed([](const std::runtime_error &e) {
    // This handler won't be invoked, because of the handler above.
});

Wenn keiner der Handler mit dem ausgelösten Ausnahmetyp übereinstimmt, wird die Ausnahme an den resultierenden Future weitergegeben:

QFuture<int> future = ...;
auto resultFuture = future.then([](int res) {
    ...
    throw Error("message");
    ...
}).onFailed([](const std::exception &e) {
    // Won't be invoked
}).onFailed([](const QException &e) {
    // Won't be invoked
});

try {
    auto result = resultFuture.result();
} catch(...) {
    // Handle the exception
}

Diese Funktion wurde in Qt 6.0 eingeführt.

Siehe auch then() und onCanceled().

[since 6.1] template <typename Function, typename = std::enable_if_t<!QtPrivate::ArgResolver<Function>::HasExtraArgs>> QFuture<T> QFuture::onFailed(QObject *context, Function &&handler)

Dies ist eine überladene Funktion.

Hängt einen Fehlerbehandler an diesen Future an, um alle Ausnahmen zu behandeln, die der Future auslöst oder die er bereits ausgelöst hat. Gibt eine QFuture vom gleichen Typ wie dieser Future zurück. Der Handler wird nur im Falle einer Ausnahme im Thread des context Objekts aufgerufen. Dies kann nützlich sein, wenn der Fehler in einem bestimmten Thread behandelt werden muss. Ein Beispiel:

// somewhere in the main thread
auto future = QtConcurrent::run([] {
    // This will run in a separate thread
    ...
    throw std::exception();
}).onFailed(this, [] {
   // Update UI elements
});

Der an QtConcurrent::run angehängte Fehler-Handler aktualisiert die UI-Elemente und kann nicht von einem Nicht-GUI-Thread aus aufgerufen werden. Daher wird this als Kontext für .onFailed() bereitgestellt, um sicherzustellen, dass er im Hauptthread aufgerufen wird.

Wenn context zerstört wird, bevor die Kette beendet ist, wird der Future abgebrochen. Siehe then() für Details.

Siehe die Dokumentation der anderen Überladung für weitere Details über handler.

Diese Funktion wurde in Qt 6.1 eingeführt.

Siehe auch then() und onCanceled().

int QFuture::progressMaximum() const

Gibt das Maximum zurück progressValue().

Siehe auch progressValue() und progressMinimum().

int QFuture::progressMinimum() const

Gibt das Minimum progressValue() zurück.

Siehe auch progressValue() und progressMaximum().

QString QFuture::progressText() const

Gibt die (optionale) textuelle Darstellung des Fortschritts zurück, wie er von der asynchronen Berechnung gemeldet wird.

Beachten Sie, dass nicht alle Berechnungen eine textuelle Darstellung des Fortschritts liefern, so dass diese Funktion eine leere Zeichenkette zurückgeben kann.

int QFuture::progressValue() const

Gibt den aktuellen Fortschrittswert zurück, der zwischen den Werten progressMinimum() und progressMaximum() liegt.

Siehe auch progressMinimum() und progressMaximum().

template <typename U = T, typename = QtPrivate::EnableForNonVoid<U>> T QFuture::result() const

Gibt das erste Ergebnis in der Zukunft zurück. Wenn das Ergebnis nicht sofort verfügbar ist, blockiert diese Funktion und wartet, bis das Ergebnis verfügbar wird. Dies ist eine praktische Methode für den Aufruf von resultAt(0). Beachten Sie, dass result() eine Kopie des intern gespeicherten Ergebnisses zurückgibt. Wenn T ein reiner Verschiebetyp ist oder Sie das Ergebnis nicht kopieren wollen, verwenden Sie stattdessen takeResult().

Siehe auch resultAt(), results(), und takeResult().

template <typename U = T, typename = QtPrivate::EnableForNonVoid<U>> T QFuture::resultAt(int index) const

Gibt das Ergebnis unter index in der Zukunft zurück. Wenn das Ergebnis nicht sofort verfügbar ist, blockiert diese Funktion und wartet, bis das Ergebnis verfügbar wird.

Siehe auch result(), results(), takeResult(), und resultCount().

int QFuture::resultCount() const

Gibt die Anzahl der in diesem future verfügbaren kontinuierlichen Ergebnisse zurück. Die tatsächliche Anzahl der gespeicherten Ergebnisse kann aufgrund von Lücken in der Ergebnismenge von diesem Wert abweichen. Es ist immer sicher, durch die Ergebnisse von 0 bis resultCount() zu iterieren.

Siehe auch result(), resultAt(), results(), und takeResult().

template <typename U = T, typename = QtPrivate::EnableForNonVoid<U>> QList<T> QFuture::results() const

Gibt alle Ergebnisse aus der Zukunft zurück. Wenn die Ergebnisse nicht sofort verfügbar sind, blockiert diese Funktion und wartet, bis sie verfügbar werden. Beachten Sie, dass results() eine Kopie der intern gespeicherten Ergebnisse zurückgibt. Das Abrufen aller Ergebnisse eines "move-only"-Typs T wird zur Zeit nicht unterstützt. Sie können jedoch immer noch durch die Liste der Nur-Bewegung-Ergebnisse iterieren, indem Sie Iteratoren im STL-Stil oder schreibgeschützte Iteratoren im Java-Stil verwenden.

Siehe auch result(), resultAt(), takeResult(), resultCount(), und isValid().

void QFuture::resume()

Setzt die asynchrone Berechnung fort, die durch future() dargestellt wird. Dies ist eine Komfortmethode, die einfach setSuspended(false) aufruft.

Siehe auch suspend().

[since 6.0] void QFuture::setSuspended(bool suspend)

Wenn suspend wahr ist, unterbricht diese Funktion die asynchrone Berechnung, die durch future() dargestellt wird. Wenn die Berechnung bereits unterbrochen ist, tut diese Funktion nichts. QFutureWatcher wird nicht sofort aufhören, Fortschritts- und Ergebnisbereitschaftssignale zu liefern, wenn der future unterbrochen wird. Zum Zeitpunkt der Unterbrechung können noch Berechnungen im Gange sein, die nicht gestoppt werden können. Die Signale für solche Berechnungen werden weiterhin ausgegeben.

Wenn suspend falsch ist, setzt diese Funktion die asynchrone Berechnung fort. Wurde die Berechnung nicht vorher unterbrochen, bewirkt diese Funktion nichts.

Beachten Sie, dass nicht alle Berechnungen unterbrochen werden können. Zum Beispiel kann die QFuture, die von QtConcurrent::run() zurückgegeben wird, nicht unterbrochen werden, aber die QFuture, die von QtConcurrent::mappedReduced() zurückgegeben wird, kann dies.

Diese Funktion wurde in Qt 6.0 eingeführt.

Siehe auch isSuspended(), suspend(), resume(), und toggleSuspended().

[since 6.0] void QFuture::suspend()

Unterbricht die asynchrone Berechnung, die durch diesen Future dargestellt wird. Dies ist eine Komfortmethode, die einfach setSuspended(true) aufruft.

Diese Funktion wurde in Qt 6.0 eingeführt.

Siehe auch resume().

[since 6.0] template <typename U = T, typename = QtPrivate::EnableForNonVoid<U>> T QFuture::takeResult()

Rufen Sie diese Funktion nur auf, wenn isValid() true zurückgibt, ansonsten ist das Verhalten undefiniert. Diese Funktion nimmt (verschiebt) das erste Ergebnis aus dem QFuture Objekt, wenn nur ein Ergebnis erwartet wird. Falls weitere Ergebnisse vorhanden sind, werden sie nach der Entnahme des ersten verworfen. Wenn das Ergebnis nicht sofort verfügbar ist, blockiert diese Funktion und wartet, bis das Ergebnis verfügbar wird. QFuture versucht, wenn möglich, die Move-Semantik zu verwenden, und greift auf die Copy-Konstruktion zurück, wenn der Typ nicht beweglich ist. Nachdem das Ergebnis übernommen wurde, wird isValid() als false ausgewertet.

Diese Funktion wurde in Qt 6.0 eingeführt.

Siehe auch result(), results(), resultAt(), und isValid().

[since 6.0] template <typename Function> QFuture<QFuture<T>::ResultType<Function>> QFuture::then(Function &&function)

Dies ist eine überladene Funktion.

Hängt eine Fortsetzung an diese Future an, die es erlaubt, mehrere asynchrone Berechnungen zu verketten, falls gewünscht, unter Verwendung der Sync Richtlinie. function ist eine aufrufbare Funktion, die ein Argument des Typs annimmt, der von dieser Future verpackt wurde, wenn diese ein Ergebnis hat (ist kein QFuture<void>). Andernfalls nimmt es keine Argumente an. Diese Methode gibt eine neue QFuture zurück, die einen Wert des Typs verpackt, der von function zurückgegeben wird. Die zurückgegebene Zukunft befindet sich in einem nicht initialisierten Zustand, bis die angehängte Fortsetzung aufgerufen wird, oder bis diese Zukunft fehlschlägt oder abgebrochen wird.

Sie können mehrere Operationen auf diese Weise verketten:

QFuture<int> future = ...;
future.then([](int res1){ ... }).then([](int res2){ ... })...

Oder:

QFuture<void> future = ...;
future.then([](){ ... }).then([](){ ... })...

Die Fortsetzung kann auch ein QFuture Argument (anstelle seines Wertes) annehmen, das die vorherige Zukunft darstellt. Dies kann nützlich sein, wenn z. B. QFuture mehrere Ergebnisse hat und der Benutzer innerhalb der Fortsetzung auf diese zugreifen möchte. Oder der Benutzer muss die Ausnahme des vorherigen Futures innerhalb der Fortsetzung behandeln, um die Kette von mehreren Fortsetzungen nicht zu unterbrechen. Zum Beispiel:

QFuture<int> future = ...;
    future.then([](QFuture<int> f) {
        try {
            ...
            auto result = f.result();
            ...
        } catch (QException &e) {
            // handle the exception
        }
    }).then(...);

Wenn der vorherige Future eine Exception auslöst und diese nicht innerhalb der Continuation behandelt wird, wird die Exception an den Continuation-Future weitergegeben, damit der Aufrufer sie behandeln kann:

QFuture<int> future = ...;
auto continuation = future.then([](int res1){ ... }).then([](int res2){ ... })...
...
// future throws an exception
try {
    auto result = continuation.result();
} catch (QException &e) {
    // handle the exception
}

In diesem Fall wird die gesamte Kette der Fortsetzungen unterbrochen.

Diese Funktion wurde in Qt 6.0 eingeführt.

Siehe auch onFailed() und onCanceled().

[since 6.1] template <typename Function> QFuture<QFuture<T>::ResultType<Function>> QFuture::then(QObject *context, Function &&function)

Dies ist eine überladene Funktion.

Hängt eine Fortsetzung an diesen Future an und ermöglicht so die Verkettung mehrerer asynchroner Berechnungen, falls gewünscht. Wenn die asynchrone Berechnung, die durch diesen Future dargestellt wird, beendet ist, wird function im Thread des context Objekts aufgerufen. Dies kann nützlich sein, wenn die Fortsetzung in einem bestimmten Thread aufgerufen werden muss. Zum Beispiel:

// somewhere in the main thread
auto future = QtConcurrent::run([] {
    // This will run in a separate thread
    ...
}).then(this, [] {
   // Update UI elements
});

Die an QtConcurrent::run angehängte Fortsetzung aktualisiert die UI-Elemente und kann nicht von einem Nicht-GUI-Thread aus aufgerufen werden. Daher wird this als Kontext für .then() bereitgestellt, um sicherzustellen, dass sie im Hauptthread aufgerufen wird.

Die folgenden Fortsetzungen werden ebenfalls aus demselben Kontext aufgerufen, es sei denn, es wird ein anderer Kontext oder eine andere Startrichtlinie angegeben:

auto future = QtConcurrent::run([] {
    ...
}).then(this, [] {
   // Update UI elements
}).then([] {
    // This will also run in the main thread
});

Dies liegt daran, dass .then() standardmäßig aus demselben Thread wie der vorherige aufgerufen wird.

Beachten Sie jedoch, dass die Fortsetzung, wenn sie angehängt wird, nachdem dieser Future bereits beendet ist, sofort in dem Thread aufgerufen wird, der then() ausführt:

QObject *context = ...;
auto future = cachedResultsReady ? QtFuture::makeReadyValueFuture(result)
                                 : QtConcurrent::run([] { /* compute result */});
auto continuation = future.then(context, [] (Result result) {
    // Runs in the context's thread
}).then([] {
    // May or may not run in the context's thread
});

Wenn im obigen Beispiel cachedResultsReady zu true wird und eine fertige Zukunft zurückgegeben wird, ist es möglich, dass die erste .then() beendet wird, bevor die zweite angehängt wird. In diesem Fall wird sie im aktuellen Thread aufgelöst. Übergeben Sie daher im Zweifelsfall den Kontext explizit.

Wenn die context zerstört wird, bevor die Kette beendet ist, wird der Future abgebrochen. Dies bedeutet, dass ein Abbruch-Handler aufgerufen werden könnte, wenn die context nicht mehr gültig ist. Um dies zu verhindern, fangen Sie die context als QPointer ein:

QObject *context = ...;
auto future = ...;
auto continuation = future.then(context, [context](Result result) {
                               // ...
                           }).onCanceled([context = QPointer(context)] {
                               if (!context)
                                   return;  // context was destroyed already
                               // handle cancellation
                           });

Wenn das Kontextobjekt zerstört wird, erfolgt der Abbruch sofort. Frühere Futures in der Kette werden nicht abgebrochen und laufen weiter, bis sie beendet sind.

Diese Funktion wurde in Qt 6.1 eingeführt.

Siehe auch onFailed() und onCanceled().

[since 6.0] template <typename Function> QFuture<QFuture<T>::ResultType<Function>> QFuture::then(QThreadPool *pool, Function &&function)

Dies ist eine überladene Funktion.

Hängt eine Fortsetzung an diesen Future an und ermöglicht so die Verkettung mehrerer asynchroner Berechnungen, falls gewünscht. Wenn die asynchrone Berechnung, die durch diesen Future repräsentiert wird, beendet ist, wird function auf pool eingeplant.

Diese Funktion wurde in Qt 6.0 eingeführt.

Siehe auch onFailed() und onCanceled().

[since 6.0] template <typename Function> QFuture<QFuture<T>::ResultType<Function>> QFuture::then(QtFuture::Launch policy, Function &&function)

Dies ist eine überladene Funktion.

Hängt eine Fortsetzung an diesen Future an und ermöglicht so die Verkettung mehrerer asynchroner Berechnungen. Wenn die asynchrone Berechnung, die durch diesen Future dargestellt wird, beendet ist, wird function entsprechend dem angegebenen Start policy aufgerufen. Es wird ein neues QFuture zurückgegeben, das das Ergebnis der Fortsetzung darstellt.

Je nach policy wird die Fortsetzung im selben Thread wie dieser Future oder in einem neuen Thread aufgerufen, oder sie erbt die Startrichtlinie und den Threadpool dieses Future. Wenn keine Startrichtlinie angegeben ist (siehe die Überladung, die nur einen Callable nimmt), wird die Richtlinie Sync verwendet.

Im folgenden Beispiel werden beide Fortsetzungen in einem neuen Thread (aber im selben) aufgerufen.

QFuture<int> future = ...;
future.then(QtFuture::Launch::Async, [](int res){ ... }).then([](int res2){ ... });

Im folgenden Beispiel werden beide Fortsetzungen in neuen Threads unter Verwendung desselben Threadpools aufgerufen.

QFuture<int> future = ...;
future.then(QtFuture::Launch::Async, [](int res){ ... })
      .then(QtFuture::Launch::Inherit, [](int res2){ ... });

Siehe die Dokumentation der anderen Überladung für weitere Details über function.

Diese Funktion wurde in Qt 6.0 eingeführt.

Siehe auch onFailed() und onCanceled().

[since 6.0] void QFuture::toggleSuspended()

Schaltet den angehaltenen Zustand der asynchronen Berechnung um. Mit anderen Worten: Wenn die Berechnung gerade unterbrochen oder ausgesetzt ist, wird sie durch den Aufruf dieser Funktion wieder aufgenommen; wenn die Berechnung läuft, wird sie ausgesetzt. Dies ist eine praktische Methode für den Aufruf von setSuspended(!(isSuspending() || isSuspended())).

Diese Funktion wurde in Qt 6.0 eingeführt.

Siehe auch setSuspended(), suspend(), und resume().

[since 6.4] template <typename U> QFuture<U> QFuture::unwrap()

Entpackt die innere Zukunft aus dieser QFuture<T>, wobei T eine Zukunft des Typs QFuture<U> ist, d.h. diese Zukunft hat den Typ QFuture<QFuture<U>>. Zum Beispiel:

QFuture<QFuture<int>> outerFuture = ...;
QFuture<int> unwrappedFuture = outerFuture.unwrap();

unwrappedFuture wird erfüllt, sobald die innere Zukunft, die in outerFuture verschachtelt ist, erfüllt ist, mit demselben Ergebnis oder derselben Ausnahme und in demselben Thread, der die innere Zukunft als beendet meldet. Wenn der innere Future abgebrochen wird, wird auch unwrappedFuture abgebrochen.

Dies ist besonders nützlich, wenn mehrere Berechnungen verkettet werden und eine davon ein QFuture als Ergebnistyp zurückgibt. Nehmen wir zum Beispiel an, wir wollen mehrere Bilder von einer URL herunterladen, die Bilder skalieren und sie mit QtConcurrent::mappedReduced() auf ein einziges Bild reduzieren. Wir könnten etwas schreiben wie:

auto downloadImages = [] (const QUrl &url) {
    QList<QImage> images;
    ...
    return images;
};

auto processImages = [](const QList<QImage> &images) {
   return QtConcurrent::mappedReduced(images, scale, reduceImages);
}

auto show = [](const QImage &image) { ... };

auto future = QtConcurrent::run(downloadImages, url)
               .then(processImages)
               .unwrap()
               .then(show);

Hier gibt QtConcurrent::mappedReduced() ein QFuture<QImage> zurück, so dass .then(processImages) ein QFuture<QFuture<QImage>> zurückgibt. Da show() ein QImage als Argument benötigt, kann das Ergebnis von .then(processImages) nicht direkt an diese Funktion übergeben werden. Wir müssen .unwrap() aufrufen, das das Ergebnis des inneren Futures erhält, wenn es fertig ist, und es an die nächste Fortsetzung weitergibt.

Im Falle einer mehrfachen Verschachtelung geht .unwrap() bis zur innersten Ebene hinunter:

QFuture<QFuture<QFuture<int>>>> outerFuture;
QFuture<int> unwrappedFuture = outerFuture.unwrap();

Diese Funktion wurde in Qt 6.4 eingeführt.

void QFuture::waitForFinished()

Wartet, bis die asynchrone Berechnung beendet ist (einschließlich der Berechnungen von cancel()ed), d. h. bis isFinished() true zurückgibt.

QFuture<T> &QFuture::operator=(const QFuture<T> &other)

Weist other diesem Future zu und gibt eine Referenz auf diesen Future zurück.