QtTaskTree::QThreadFunction Class

static void copyFile(QPromise<void> &promise, const QString &source,
                     const QString &destination)
{
    const QFileInfo fi(source);
    if (!fi.exists()) {
        promise.future().cancel(); // The QThreadFunction finishes with DoneResult::Error
        return;
    }

    // Copy file...
}

QThreadFunction<void> task;
task.setThreadFunctionData(copyFile, "source.txt", "dest.txt");
task.start();

Documentation des fonctions membres

[implicit] QThreadFunction::QThreadFunction(QObject *parent = nullptr)

Crée un objet `QThreadFunction` avec un ` parent` donné.

[override virtual] QThreadFunction::~QThreadFunction()

Supprime l'QThreadFunction. Si l'QThreadFunction n'est pas en cours d'exécution, aucune autre action n'est effectuée ; dans le cas contraire, le « future » associé est annulé et, en fonction de la synchronisation différée automatique, les actions suivantes sont effectuées :

Lorsque la synchronisation différée automatique est activée, l’annulation de la tâche future peut être interceptée au sein de la fonction encore en cours d’exécution dans un thread distinct, de sorte qu’elle puisse se terminer dès que possible sans avoir achevé sa tâche.

Enfin, à la fermeture de l’application, la fonction ` QThreadFunctionBase::syncAll()` doit être appelée afin de synchroniser toutes les fonctions susceptibles d’être encore en cours d’exécution dans des threads distincts. L’appel à ` QThreadFunctionBase::syncAll()` est bloquant au cas où certaines fonctions seraient encore en cours de finalisation.

Voir également setAutoDelayedSync() et syncAll().

QFuture<ResultType> QThreadFunction::future() const

Renvoie l'QFuture e <ResultType> associé à la fonction exécutée dans un thread distinct.

QFutureWatcher<ResultType> *QThreadFunction::futureWatcher()

Renvoie le pointeur vers l'QFutureWatcher<ResultType> associé à la fonction exécutée dans un thread distinct. La durée de vie de l' renvoyé est liée à l'instance d'QThreadFunction.

Utilisez cette fonction si vous avez besoin d'un contrôle accru sur l'exécution future, par exemple pour vous connecter aux signaux de progression de l'observateur renvoyé.

const QFutureWatcher<ResultType> *QThreadFunction::futureWatcher() const

Renvoie le pointeur « const » vers l’objet « QFutureWatcher<ResultType> » associé à la fonction exécutée dans un thread distinct.

bool QThreadFunction::isAutoDelayedSync() const

Indique si la synchronisation différée automatique est activée.

Voir également syncAll() et setAutoDelayedSync().

bool QThreadFunction::isDone() const

Indique si l'exécution de la fonction est terminée.

bool QThreadFunction::isResultAvailable() const

Indique si le résultat est prêt.

Voir également result().

ResultType QThreadFunction::result() const

Renvoie le ResultType signalé par la fonction exécutée dans un thread distinct.

Voir également QFutureWatcher::result().

ResultType QThreadFunction::resultAt(int index) const

Renvoie le ResultType signalé par la fonction exécutée dans un thread distinct à l'adresse index.

Voir également result() et QFutureWatcher::resultAt().

QList<ResultType> QThreadFunction::results() const

Renvoie la liste des objets de type ResultType renvoyés par la fonction exécutée dans un thread distinct.

Voir également result(), resultAt() et QFuture::results().

void QThreadFunction::setAutoDelayedSync(bool on)

Définit la synchronisation différée automatique sur ` on`.

Par défaut, la synchronisation différée automatique est activée, ce qui signifie que la destruction de l’objet ` QThreadFunction ` en cours d’exécution n’entraînera pas d’attente bloquante jusqu’à ce que la fonction s’exécutant dans un thread séparé soit terminée. Au lieu de cela, l’ QFuture ` associée est annulée, et la fonction continue de s’exécuter jusqu’à ce qu’elle soit terminée. L'annulation peut être interceptée par la fonction s'exécutant dans un thread séparé via l’argument ` QPromise `, de sorte qu’elle puisse se terminer prématurément sans avoir achevé sa tâche. Si la synchronisation différée automatique est activée, il est nécessaire d’appeler ` QThreadFunctionBase::syncAll()` à la fermeture de l’application, afin de synchroniser toutes les fonctions susceptibles de s’exécuter dans des threads séparés.

Lorsque la synchronisation différée automatique est désactivée, la synchronisation a lieu lors de la destruction de ` QThreadFunction`, ce qui peut bloquer le thread appelant pendant un temps considérable.

La synchronisation automatique n’est utilisée que lorsque la fonction ` QThreadFunction ` a été exécutée depuis le thread principal.

Voir également syncAll() et isAutoDelayedSync().

template <typename Function, typename... Args> void QThreadFunction::setThreadFunctionData(Function &&function, Args &&... args)

Définit l'function, qui sera exécutée avec les paramètres args transmis dans un thread distinct lors de l'appel de la fonction start().

Voir également QtConcurrent::run().

void QThreadFunction::setThreadPool(QThreadPool *pool)

Définit l'QThreadPool pool à utiliser lors de l'exécution de l'appel. Si l'pool transmis est nullptr, la fonction QThreadPool::globalInstance() est utilisée.

Voir également threadPool().

ResultType QThreadFunction::takeResult() const

Récupère (transfère) le `ResultType` renvoyé par la fonction exécutée dans un thread distinct.

Voir également QFuture::takeResult().

QThreadPool *QThreadFunction::threadPool() const

Renvoie le pool de threads utilisé lors de l'exécution de l'appel. Si la valeur « nullptr » est renvoyée, la fonction ` QThreadPool::globalInstance()` est utilisée.

Voir également setThreadPool().