특정 Qt 스레드에서 Functor 또는 Lambda를 실행하는 방법은 무엇입니까?

Qt, GCD 스타일의 특정 스레드에서 펑터나 람다를 실행하는 방법은 무엇입니까?

문제:

GCD가 있는 ObjC에서는 다음 중 어느 곳에서나 람다를 실행할 수 있습니다. dispatch_sync 또는 dispatch_async 함수를 사용하여 이벤트 루프를 회전시키는 스레드입니다. 이는 메인 스레드의 대기열에서 차단 또는 비동기적으로 무언가(C의 [] { /* do sth */ }와 동일)를 실행합니다. Qt에서 어떻게 동일한 작업을 수행할 수 있습니까?

해결책:

Qt에서는 펑터를 소비자 객체로 래핑하는 이벤트를 전달하여 유사한 동작을 달성할 수 있습니다. 원하는 스레드에 상주하는 이 프로세스를 메타콜 게시라고 합니다. 이를 수행하는 방법은 다음과 같습니다.

Qt 5.10 이상 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),
                         []{ ... });

펑터 Qt 5.10 및 TL;DR up

// 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 Qt 5.10 이상

// 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 이상 TL;DR: 싱글샷은 어떻습니까? 타이머?</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>

공통 코드 Qt 5.10 이상

#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>

임시 개체를 신호로 사용하는 Qt 4/5 솔루션 출처

#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>

QEvent 소멸자를 사용하는 Qt 4/5 솔루션

#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>Private을 사용하는 Qt 5 솔루션 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>

사용자 정의 이벤트 및 소비자를 사용하는 Qt 4/5 솔루션

#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>

위 내용은 특정 Qt 스레드에서 Functor 또는 Lambda를 실행하는 방법은 무엇입니까?의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!