Comment exécuter des foncteurs ou des Lambdas dans des threads Qt spécifiques ?

Comment exécuter un foncteur ou un lambda dans un thread donné en Qt, style GCD ?

Problème :

Dans ObjC avec GCD, vous pouvez exécuter un lambda dans n'importe lequel des threads qui exécutent un événement boucle en utilisant les fonctions dispatch_sync ou dispatch_async. Il exécute quelque chose (équivalent à [] { /* do sth */ } en C ) dans la file d'attente du thread principal, soit de manière bloquante, soit de manière asynchrone. Comment pouvez-vous faire la même chose dans Qt ?

Solution :

Dans Qt, vous pouvez obtenir un comportement similaire en délivrant un événement qui enveloppe le foncteur dans un objet consommateur résidant dans le thread souhaité, un processus connu sous le nom de publication de métaappels. Voici comment procéder :

Qt 5.10 et plus TL;DR

// invoke on the main thread
QMetaObject::invokeMethod(qApp, []{ ... });

// invoke on an object's thread
QMetaObject::invokeMethod(obj, []{ ... });

// invoke on a particular thread
QMetaObject::invokeMethod(QAbstractEventDispatcher::instance(thread),
                         []{ ... });

TL;DR pour les foncteurs Qt 5.10 et plus

// https://github.com/KubaO/stackoverflown/tree/master/questions/metacall-21646467

// Qt 5.10 & up - it's all done

template <typename f>
static void postToObject(F &&fun, QObject *obj = qApp) {
  QMetaObject::invokeMethod(obj, std::forward<f>(fun));
}

template <typename f>
static void postToThread(F && fun, QThread *thread = qApp->thread()) {
   auto *obj = QAbstractEventDispatcher::instance(thread);
   Q_ASSERT(obj);
   QMetaObject::invokeMethod(obj, std::forward<f>(fun));
}</f></typename></f></typename>

TL;DR pour les méthodes/slots Qt 5.10 et plus

// Qt 5/4
template <typename t typename r>
static void postToObject(T * obj, R(T::* method)()) {
   struct Event : public QEvent {
      T * obj;
      R(T::* method)();
      Event(T * obj, R(T::*method)()):
         QEvent(QEvent::None), obj(obj), method(method) {}
      ~Event() { (obj->*method)(); }
   };
   if (qobject_cast<qthread>(obj))
      qWarning() <p><strong>Qt 5.10 et plus TL;DR : Qu'en est-il d'une minuterie à prise unique ?</strong></p>
<pre class="brush:php;toolbar:false">template <typename f>
static void postToObject(F && fun, QObject * obj = qApp) {
   if (qobject_cast<qthread>(obj))
      qWarning() (fun));
}</qthread></typename>

Code commun Qt 5.10 & up

#ifndef HAS_FUNCTORCALLCONSUMER
namespace FunctorCallConsumer {
   bool needsRunningThread() { return true; }
   QObject * forThread(QThread * thread) {
      Q_ASSERT(thread);
      QObject * target = thread == qApp->thread()
            ? static_cast<qobject>(qApp) : QAbstractEventDispatcher::instance(thread);
      Q_ASSERT_X(target, "postMetaCall", "the receiver thread must have an event loop");
      return target;
   }
}
#endif</qobject>

Solution Qt 4/5 utilisant un objet temporaire comme source de signal

#include <qtcore>
#include <functional>

namespace FunctorCallConsumer { QObject * forThread(QThread*); }

#define HAS_POSTMETACALL
void postMetaCall(QThread * thread, const std::function<void> & fun) {
   QObject signalSource;
   QObject::connect(&signalSource, &QObject::destroyed,
                    FunctorCallConsumer::forThread(thread), [=](QObject*){ fun(); });
}
#ifdef __cpp_init_captures
void postMetaCall(QThread * thread, std::function<void> && fun) {
   QObject signalSource;
   QObject::connect(&signalSource, &QObject::destroyed,
                    FunctorCallConsumer::forThread(thread), [fun(std::move(fun))](QObject*){ fun(); });
}
#endif</void></void></functional></qtcore>

Solution Qt 4/5 utilisant QEvent Destructor

#include <qtcore>
#include <functional>

class FunctorCallEvent : public QEvent {
   std::function<void> m_fun;
   QThread * m_thread;
public:
   FunctorCallEvent(const std::function<void> & fun, QObject * receiver) :
      QEvent(QEvent::None), m_fun(fun), m_thread(receiver->thread()) {}
   FunctorCallEvent(std::function<void> && fun, QObject * receiver) :
      QEvent(QEvent::None), m_fun(std::move(fun)), m_thread(receiver->thread()) { qDebug() <p><strong>Solution Qt 5 utilisant le QMetaCallEvent</strong></p>
<pre class="brush:php;toolbar:false">#include <qtcore>
#include <private>
#include <functional>

class FunctorCallEvent : public QMetaCallEvent {
public:
   template <typename functor>
   FunctorCallEvent(Functor && fun, QObject * receiver) :
      QMetaCallEvent(new QtPrivate::QFunctorSlotObject<functor typename qtprivate::list_left>::Value, void>
                     (std::forward<functor>(fun)), receiver, 0, 0, 0, (void**)malloc(sizeof(void*))) {}
};</functor></functor></typename></functional></private></qtcore>

Solution Qt 4/5 utilisant un événement et un consommateur personnalisés

#include <qtcore>
#include <functional>

class FunctorCallEvent : public QEvent {
   std::function<void> m_fun;
public:
   FunctorCallEvent(const std::function<void> & fun, QObject *) :
      QEvent(QEvent::None), m_fun(fun) {}
   FunctorCallEvent(std::function<void> && fun, QObject *) :
      QEvent(QEvent::None), m_fun(std::move(fun)) { qDebug()  Map;
   static QObject * m_appThreadObject;
   static QMutex m_threadObjectMutex;
   static Map m_threadObjects;
   bool event(QEvent * ev) {
      if (!dynamic_cast<functorcallevent>(ev)) return QObject::event(ev);
      static_cast<functorcallevent>(ev)->call();
      return true;
   }
};</functorcallevent></functorcallevent></void></void></void></functional></qtcore>

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!