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

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

Construit une QThreadFunction avec une parent donnée.

[override virtual] QThreadFunction::~QThreadFunction()

Détruit le site QThreadFunction. Si le site QThreadFunction n'est pas en cours d'exécution, aucune autre action n'est exécutée, sinon le futur associé est annulé et, en fonction de la synchronisation automatique retardée, les actions suivantes sont exécutées :

Lorsque la synchronisation différée automatique est activée, l'annulation du futur peut être interceptée par la fonction encore en cours d'exécution dans un thread séparé, de manière à ce qu'elle puisse se terminer le plus tôt possible sans avoir achevé son travail.

Enfin, lorsque l'application est quittée, QThreadFunctionBase::syncAll() doit être appelé afin de synchroniser toutes les fonctions encore potentiellement 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 le QFuture<ResultType> associé à la fonction exécutée dans un thread séparé.

QFutureWatcher<ResultType> *QThreadFunction::futureWatcher()

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

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

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

Renvoie le pointeur const sur le site QFutureWatcher<ResultType> associé à la fonction exécutée dans un thread séparé.

bool QThreadFunction::isAutoDelayedSync() const

Retourne si la synchronisation automatique retardée est activée.

Voir aussi syncAll() et setAutoDelayedSync().

bool QThreadFunction::isDone() const

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

bool QThreadFunction::isResultAvailable() const

Retourne si le résultat est prêt.

Voir aussi result().

ResultType QThreadFunction::result() const

Renvoie le ResultType rapporté par la fonction exécutée dans un thread séparé.

Voir aussi QFutureWatcher::result().

ResultType QThreadFunction::resultAt(int index) const

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

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

QList<ResultType> QThreadFunction::results() const

Renvoie la liste des ResultType rapportés par la fonction exécutée dans un thread séparé.

Voir aussi result(), resultAt() et QFuture::results().

void QThreadFunction::setAutoDelayedSync(bool on)

Définit la synchronisation automatique retardée à 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'attendra pas en bloc que la fonction exécutée dans un thread séparé soit terminée. Au lieu de cela, l'objet QFuture associé est annulé et la fonction est laissée en cours d'exécution 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 peut se terminer plus tôt sans avoir achevé son travail. Si la synchronisation automatique retardée est activée, il est nécessaire d'appeler QThreadFunctionBase::syncAll() à la sortie de l'application, afin de synchroniser toutes les fonctions éventuellement en cours d'exécution dans des threads distincts.

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

La synchronisation automatique n'est utilisée que lorsque QThreadFunction a été exécuté à partir du thread principal.

Voir aussi syncAll() et isAutoDelayedSync().

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

Définit le function à exécuter avec le args passé dans un thread séparé lorsque start() est appelé.

Voir aussi QtConcurrent::run().

void QThreadFunction::setThreadPool(QThreadPool *pool)

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

Voir aussi threadPool().

ResultType QThreadFunction::takeResult() const

Prend (déplace) le ResultType rapporté par la fonction exécutée dans un thread séparé.

Voir aussi QFuture::takeResult().

QThreadPool *QThreadFunction::threadPool() const

Renvoie le pool de threads utilisé lors de l'exécution de l'appel. Si nullptr est renvoyé, c'est QThreadPool::globalInstance() qui est utilisé.

Voir aussi setThreadPool().