GCDを備えたObjCでは、イベントループをスピンする任意のスレッドでラムダを実行する方法があります。例えば:
_dispatch_sync(dispatch_get_main_queue(), ^{ /* do sth */ });
_
または:
_dispatch_async(dispatch_get_main_queue(), ^{ /* do sth */ });
_
メインスレッドのキュー内で何か(C++の_[]{ /* do sth */ }
_と同等)をブロックまたは非同期で実行します。
Qtで同じようにするにはどうすればよいですか?
私が読んだことから、解決策は、どういうわけか、メインスレッドのオブジェクトに信号を送信することだと思います。しかし、どのオブジェクトですか?ただQApplication::instance()
? (それがその時点でメインスレッドに存在する唯一のオブジェクトです。)そして、どのようなシグナルですか?
現在の答えと私の現在の研究から、メインスレッドにいくつかのダミーオブジェクトが必要であるように思えます。スロットはいくつかのコードが実行されるのを待つだけです。
そこで、QApplication
をサブクラス化して追加することにしました。動作しない私の現在のコード(しかし、おそらくあなたは助けることができます):
_#include <QApplication>
#include <QThread>
#include <QMetaMethod>
#include <functional>
#include <assert.h>
class App : public QApplication
{
Q_OBJECT
public:
App();
signals:
public slots:
void genericExec(std::function<void(void)> func) {
func();
}
private:
// cache this
QMetaMethod genericExec_method;
public:
void invokeGenericExec(std::function<void(void)> func, Qt::ConnectionType connType) {
if(!genericExec_method) {
QByteArray normalizedSignature = QMetaObject::normalizedSignature("genericExec(std::function<void(void)>)");
int methodIndex = this->metaObject()->indexOfSlot(normalizedSignature);
assert(methodIndex >= 0);
genericExec_method = this->metaObject()->method(methodIndex);
}
genericExec_method.invoke(this, connType, Q_ARG(std::function<void(void)>, func));
}
};
static inline
void execInMainThread_sync(std::function<void(void)> func) {
if(qApp->thread() == QThread::currentThread())
func();
else {
((App*) qApp)->invokeGenericExec(func, Qt::BlockingQueuedConnection);
}
}
static inline
void execInMainThread_async(std::function<void(void)> func) {
((App*) qApp)->invokeGenericExec(func, Qt::QueuedConnection);
}
_
それは確かに可能です。どのソリューションでも、目的のスレッドに常駐するコンシューマーオブジェクトにファンクターをラップするイベントを配信することが中心になります。この操作をメタコールポストと呼びます。詳細はいくつかの方法で実行できます。
_// 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),
[]{ ... });
_
_// 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));
}
// Qt 5/4 - preferred, has least allocations
namespace detail {
template <typename F>
struct FEvent : public QEvent {
using Fun = typename std::decay<F>::type;
Fun fun;
FEvent(Fun && fun) : QEvent(QEvent::None), fun(std::move(fun)) {}
FEvent(const Fun & fun) : QEvent(QEvent::None), fun(fun) {}
~FEvent() { fun(); }
}; }
template <typename F>
static void postToObject(F && fun, QObject * obj = qApp) {
if (qobject_cast<QThread*>(obj))
qWarning() << "posting a call to a thread object - consider using postToThread";
QCoreApplication::postEvent(obj, new detail::FEvent<F>(std::forward<F>(fun)));
}
template <typename F>
static void postToThread(F && fun, QThread * thread = qApp->thread()) {
QObject * obj = QAbstractEventDispatcher::instance(thread);
Q_ASSERT(obj);
QCoreApplication::postEvent(obj, new detail::FEvent<F>(std::forward<F>(fun)));
}
_
_// Qt 5 - alternative version
template <typename F>
static void postToObject2(F && fun, QObject * obj = qApp) {
if (qobject_cast<QThread*>(obj))
qWarning() << "posting a call to a thread object - consider using postToThread";
QObject src;
QObject::connect(&src, &QObject::destroyed, obj, std::forward<F>(fun),
Qt::QueuedConnection);
}
template <typename F>
static void postToThread2(F && fun, QThread * thread = qApp->thread()) {
QObject * obj = QAbstractEventDispatcher::instance(thread);
Q_ASSERT(obj);
QObject src;
QObject::connect(&src, &QObject::destroyed, obj, std::forward<F>(fun),
Qt::QueuedConnection);
}
_
_void test1() {
QThread t;
QObject o;
o.moveToThread(&t);
// Execute in given object's thread
postToObject([&]{ o.setObjectName("hello"); }, &o);
// or
postToObject(std::bind(&QObject::setObjectName, &o, "hello"), &o);
// Execute in given thread
postToThread([]{ qDebug() << "hello from worker thread"; });
// Execute in the main thread
postToThread([]{ qDebug() << "hello from main thread"; });
}
_
_// 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() << "posting a call to a thread object - this may be a bug";
QCoreApplication::postEvent(obj, new Event(obj, method));
}
void test2() {
QThread t;
struct MyObject : QObject { void method() {} } obj;
obj.moveToThread(&t);
// Execute in obj's thread
postToObject(&obj, &MyObject::method);
}
_
上記のすべてのメソッドは、イベントループを持たないスレッドから機能します。 QTBUG-66458 のため、_QTimer::singleShot
_を簡単に使用するには、ソーススレッドにもイベントループが必要です。次に、postToObject
は非常に単純になり、_QTimer::singleShot
_を直接使用することもできますが、この慣用句に慣れていない人から意図を隠すのは厄介な名前です。型チェックが必要ない場合でも、意図をより適切に示すために名前が付けられた関数を介した間接参照は意味があります。
_template <typename F>
static void postToObject(F && fun, QObject * obj = qApp) {
if (qobject_cast<QThread*>(obj))
qWarning() << "posting a call to a thread object - consider using postToThread";
QTimer::singleShot(0, obj, std::forward<F>(fun));
}
_
次の一般的なコードで問題を定義してみましょう。最も単純なソリューションは、ターゲットスレッドがメインスレッドである場合に限り、アプリケーションオブジェクトにイベントをポストするか、他の特定のスレッドのイベントディスパッチャーにポストします。イベントディスパッチャーは_QThread::run
_が入力された後にのみ存在するため、needsRunningThread
からtrueを返すことにより、スレッドが実行されている必要があることを示します。
_#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
_
メタコールポスト関数は、最も単純な形式で、ファンクターコールコンシューマーが特定のスレッドにオブジェクトを提供し、ファンクターコールイベントをインスタンス化することを要求します。イベントの実装はまだ先に進んでおり、さまざまな実装間の本質的な違いです。
2番目のオーバーロードはファンクターの右辺値参照を取り、ファンクターでのコピー操作を保存する可能性があります。これは、継続にコピーにコストがかかるデータが含まれている場合に役立ちます。
_#ifndef HAS_POSTMETACALL
void postMetaCall(QThread * thread, const std::function<void()> & fun) {
auto receiver = FunctorCallConsumer::forThread(thread);
QCoreApplication::postEvent(receiver, new FunctorCallEvent(fun, receiver));
}
void postMetaCall(QThread * thread, std::function<void()> && fun) {
auto receiver = FunctorCallConsumer::forThread(thread);
QCoreApplication::postEvent(receiver,
new FunctorCallEvent(std::move(fun), receiver));
}
#endif
_
デモンストレーションの目的で、ワーカースレッドはまずメタコールをメインスレッドにポストし、次にQThread::run()
を使用してイベントループを開始し、他のスレッドからのメタコールの可能性をリッスンします。 mutexは、コンシューマーの実装で必要な場合に、スレッドユーザーがスレッドの開始を簡単な方法で待機できるようにするために使用されます。このような待機は、上記のデフォルトのイベントコンシューマに必要です。
_class Worker : public QThread {
QMutex m_started;
void run() {
m_started.unlock();
postMetaCall(qApp->thread(), []{
qDebug() << "worker functor executes in thread" << QThread::currentThread();
});
QThread::run();
}
public:
Worker(QObject * parent = 0) : QThread(parent) { m_started.lock(); }
~Worker() { quit(); wait(); }
void waitForStart() { m_started.lock(); m_started.unlock(); }
};
_
最後に、メタコールをメイン(アプリケーション)スレッドにポストする上記のワーカースレッドを開始し、アプリケーションスレッドがメタコールをワーカースレッドにポストします。
_int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
a.thread()->setObjectName("main");
Worker worker;
worker.setObjectName("worker");
qDebug() << "worker thread:" << &worker;
qDebug() << "main thread:" << QThread::currentThread();
if (FunctorCallConsumer::needsRunningThread()) {
worker.start();
worker.waitForStart();
}
postMetaCall(&worker, []{ qDebug() << "main functor executes in thread" << QThread::currentThread(); });
if (!FunctorCallConsumer::needsRunningThread()) worker.start();
QMetaObject::invokeMethod(&a, "quit", Qt::QueuedConnection);
return a.exec();
}
_
出力は、すべての実装で次のようになります。ファンクタはスレッドを横断します。メインスレッドで作成されたファンクタはワーカースレッドで実行され、その逆も同様です。
_worker thread: QThread(0x7fff5692fc20, name = "worker")
main thread: QThread(0x7f86abc02f00, name = "main")
main functor executes in thread QThread(0x7fff5692fc20, name = "worker")
worker functor executes in thread QThread(0x7f86abc02f00, name = "main")
_
Qt 5の最も簡単なアプローチは、一時的なQObject
を信号ソースとして使用し、ファンクターをそのdestroyed(QObject*)
信号に接続することです。 postMetaCall
が戻ると、signalSource
が破壊され、そのdestroyed
信号を発信して、メタコールをプロキシオブジェクトにポストします。
これは、おそらくC++ 11スタイルで最も簡潔で簡単な実装です。 signalSource
オブジェクトは、破壊の副作用のためにC++ 11 RAII形式で使用されます。 「副作用」という語句はC++ 11のセマンティクス内での意味を持ち、「信頼できない」または「望ましくない」という意味で解釈されるべきではありません。 QObject
との契約では、デストラクタの実行中にdestroyed
を発行することになっています。その事実を利用することは大歓迎です。
_#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
// Common Code follows here
_
メインスレッドに投稿するだけの場合、コードはほとんど取るに足らないものになります。
_void postToMainThread(const std::function<void()> & fun) {
QObject signalSource;
QObject::connect(&signalSource, &QObject::destroyed, qApp, [=](QObject*){
fun();
});
}
#ifdef __cpp_init_captures
void postToMainThread(std::function<void()> && fun) {
QObject signalSource;
QObject::connect(&signalSource, &QObject::destroyed, qApp, [fun(std::move(fun))](QObject*){
fun();
});
}
#endif
_
同じアプローチを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() << "move semantics"; }
~FunctorCallEvent() {
if (QThread::currentThread() == m_thread)
m_fun();
else
qWarning() << "Dropping a functor call destined for thread" << m_thread;
}
};
// Common Code follows here
_
メインスレッドのみに投稿することで、物事はさらに簡単になります:
_class FunctorCallEvent : public QEvent {
std::function<void()> m_fun;
public:
FunctorCallEvent(const std::function<void()> & fun) :
QEvent(QEvent::None), m_fun(fun) {}
FunctorCallEvent(std::function<void()> && fun, QObject * receiver) :
QEvent(QEvent::None), m_fun(std::move(fun)) {}
~FunctorCallEvent() {
m_fun();
}
};
void postToMainThread(const std::function<void()> & fun) {
QCoreApplication::postEvent(qApp, new FunctorCallEvent(fun);
}
void postToMainThread(std::function<void()> && fun) {
QCoreApplication::postEvent(qApp, new FunctorCallEvent(std::move(fun)));
}
_
ファンクタは、QMetaCallEvent
のQt 5スロットオブジェクトペイロードにラップできます。ファンクタは_QObject::event
_によって呼び出されるため、ターゲットスレッドの任意のオブジェクトにポストできます。このソリューションでは、Qt 5のプライベート実装の詳細を使用します。
_#include <QtCore>
#include <private/qobject_p.h>
#include <functional>
class FunctorCallEvent : public QMetaCallEvent {
public:
template <typename Functor>
FunctorCallEvent(Functor && fun, QObject * receiver) :
QMetaCallEvent(new QtPrivate::QFunctorSlotObject<Functor, 0, typename QtPrivate::List_Left<void, 0>::Value, void>
(std::forward<Functor>(fun)), receiver, 0, 0, 0, (void**)malloc(sizeof(void*))) {}
// Metacalls with slot objects require an argument array for the return type, even if it's void.
};
// Common Code follows here
_
オブジェクトのevent()
メソッドを再実装し、ファンクターを呼び出します。これは、ファンクタがポストされる各スレッドで明示的なイベントコンシューマオブジェクトを必要とします。オブジェクトは、スレッドが終了したとき、またはメインスレッドの場合はアプリケーションインスタンスが破棄されたときにクリーンアップされます。 Qt 4とQt 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() << "move semantics"; }
void call() { m_fun(); }
};
#define HAS_FUNCTORCALLCONSUMER
class FunctorCallConsumer : public QObject {
typedef QMap<QThread*, FunctorCallConsumer*> 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;
}
FunctorCallConsumer() {}
~FunctorCallConsumer() {
qDebug() << "consumer done for thread" << thread();
Q_ASSERT(thread());
QMutexLocker lock(&m_threadObjectMutex);
m_threadObjects.remove(thread());
}
static void deleteAppThreadObject() {
delete m_appThreadObject;
m_appThreadObject = nullptr;
}
public:
static bool needsRunningThread() { return false; }
static FunctorCallConsumer * forThread(QThread * thread) {
QMutexLocker lock(&m_threadObjectMutex);
Map map = m_threadObjects;
lock.unlock();
Map::const_iterator it = map.find(thread);
if (it != map.end()) return *it;
FunctorCallConsumer * consumer = new FunctorCallConsumer;
consumer->moveToThread(thread);
if (thread != qApp->thread())
QObject::connect(thread, SIGNAL(finished()), consumer, SLOT(deleteLater()));
lock.relock();
it = m_threadObjects.find(thread);
if (it == m_threadObjects.end()) {
if (thread == qApp->thread()) {
Q_ASSERT(! m_appThreadObject);
m_appThreadObject = consumer;
qAddPostRoutine(&deleteAppThreadObject);
}
m_threadObjects.insert(thread, consumer);
return consumer;
} else {
delete consumer;
return *it;
}
}
};
QObject * FunctorCallConsumer::m_appThreadObject = nullptr;
QMutex FunctorCallConsumer::m_threadObjectMutex;
FunctorCallConsumer::Map FunctorCallConsumer::m_threadObjects;
// Common Code follows here
_
このようなものは何か役に立ちますか?
template <typename Func>
inline static void MyRunLater(Func func) {
QTimer *t = new QTimer();
t->moveToThread(qApp->thread());
t->setSingleShot(true);
QObject::connect(t, &QTimer::timeout, [=]() {
func();
t->deleteLater();
});
QMetaObject::invokeMethod(t, "start", Qt::QueuedConnection, Q_ARG(int, 0));
}
このコードにより、ラムダが可能な限りすぐにメインスレッドイベントループで実行されます。引数のサポートはありません。これは非常に基本的なコードです。
注:正しくテストしていません。
私が考える最も簡単な新しいアプローチが1つあります。 Qt 5.4からです。 ドキュメントへのリンク
void QTimer::singleShot(int msec, const QObject *context, Functor functor)
例:
QTimer::singleShot(0, qApp, []()
{
qDebug() << "hi from event loop";
});
ラムダはqAppスレッド(メインスレッド)で実行されます。コンテキストを任意のQObjectに置き換えることができます。
更新
QTimerが機能するにはイベントループが必要です。 qtイベントループ(std :: thread)のないスレッドの場合は、作成できます。 std :: threadでラムダを実行するコード。
QEventLoop loop;
Q_UNUSED(loop)
QTimer::singleShot(0, qApp, []()
{
qDebug() << "singleShot from std thread";
});
完全な例
#include <QCoreApplication>
#include <QTimer>
#include <QDebug>
#include <thread>
#include <QThread>
#include <QEventLoop>
#include <QThread>
using std::thread;
class TestObj
:public QObject
{
// Used new connect syntax no need for Q_OBJECT define
// you SHOULD use it. I used just to upload one file
//Q_OBJECT
public slots:
void doWork()
{
qDebug() << "QThread id" << QThread::currentThreadId();
QTimer::singleShot(0, qApp, []()
{
qDebug() << "singleShot from QThread" << QThread::currentThreadId();
});
}
};
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
qDebug() << "main thread id" << QThread::currentThreadId();
thread testThread([]()
{
QEventLoop loop;
Q_UNUSED(loop)
qDebug() << "std::thread id" << QThread::currentThreadId();
QTimer::singleShot(0, qApp, []()
{
qDebug() << "singleShot from std thread" << QThread::currentThreadId();
});
qDebug() << "std::thread finished";
});
testThread.detach();
QThread testQThread;
TestObj testObj;
testObj.moveToThread(&testQThread);
QObject::connect(&testQThread, &QThread::started, &testObj, &TestObj::doWork);
testQThread.start();
return a.exec();
}
他には素晴らしい答えがあります。ここに私の提案があります。このようなことをする代わりに:-
QMetaObject::invokeMethod(socketManager,"newSocket",
Qt::QueuedConnection,
Q_ARG(QString, Host),
Q_ARG(quint16, port.toUShort()),
Q_ARG(QString, username),
Q_ARG(QString, passhash)
);
より良いですこのような何かをしてください:-
QMetaObject::invokeMethod(socketManager,[=](){
socketManager->newSocket(Host,port.toUShort(),username,passhash);
},Qt::QueuedConnection);