在没有连接的情况下调用槽方法？

Question

我有一个通过以下方式实现的活动对象。它用于在后台执行长时间任务。主线程通过向公共槽发送信号（即 doTask）来调用任务。这是一个精简的示例（未经测试）。

class MyTask : public QObject
{
    Q_OBJECT

public:
    MyTask();
    ~MyTask();

public slots:
    void doTask( int param );

private slots:
    void stated();

signals:
    void taskCompleted( int result );

private:
    QThread m_thread;
};


MyTask::MyTask()
{
   moveToThread(&m_thread);
   connect( &m_thread, SIGNAL(started()), this, SLOT(started()));
   m_thread.start();
}

MyTask::~MyTask()
{
    // Gracefull thread termination (queued in exec loop)
    if( m_thread.isRunning() )
    {
        m_thread.quit();
        m_thread.wait();
    }
}

void MyTask::started()
{
    // initialize live object
}

void MyTask::doTask( int param )
{
    sleep( 10 );
    emit taskCompleted( param*2 );
}

只要 doTask() 被信号调用，这（应该）按预期工作。但是如果主线程直接调用doTask()，那么它将由主线程执行。对于某些任务，我想强制由活动对象的线程执行，即使直接调用槽方法也是如此。

我可以在 doTask() 前面添加代码来检查当前线程是否为 m_thread，在这种情况下它会执行该方法。如果不是，我希望 doTask() 向“this”发出信号，以便 doTask() 的调用在 m_thread exec 循环中排队并尽快由它执行。

我怎么能这么做呢？

编辑：根据建议的答案，这是新代码。 doTask 方法现在委托活动对象的线程执行，即使是由主线程直接调用也是如此。通过信号调用仍然按预期工作。

class MyTask : public QObject
{
    Q_OBJECT

public:
    explicit MyTask( QObject *parent = 0 );
    ~MyTask();

public slots:
    void doTask( int param );

private slots:
    void doTaskImpl( int param );

signals:
    void taskCompleted( int result );

private:
    QThread m_thread;
};

MyTask::MyTask( QObject *parent) : QObject(parent)
{
   moveToThread(&m_thread);
   m_thread.start();
}

MyTask::~MyTask()
{
    // Gracefull thread termination (queued in exec loop)
    if( m_thread.isRunning() )
    {
        m_thread.quit();
        m_thread.wait();
    }
}

void MyTask::doTask( int param )
{
    QMetaObject::invokeMethod( this, "doTaskImpl", Q_ARG( int, param ) );
}

void MyTask::doTaskImpl( int param )
{
    // Do the live oject's asynchronous task
    sleep( 10 );
    emit taskCompleted( param*2 );
}

这是我能找到的支持在单独线程中执行异步方法的最简单的实现。 doTask() 方法的调用将在线程启动后立即排队并进行处理。当从对象线程调用时，它将立即执行（不排队）。

请注意，started() 信号仅在线程启动时发出。这意味着在线程启动之前排队的 doTask() 方法调用将在调用started() 方法槽之前执行。这就是我从最初的实现中删除它的原因。因此，对象初始化最好在构造函数中执行。

Answer 1

您想调用 QMetaObject::invokeMethod来做到这一点。在你的情况下，它看起来像

MyTask *task;
int param;
// ...
// Will automatically change threads, if needed, to execute 
// the equivalent of:
// (void)task->doTask( param );
QMetaObject::invokeMethod( task, "doTask", Q_ARG( int, param ) );

Answer 2

我要添加的唯一改进是节省查找方法的时间：

class MyTask {
// ...
private:
  int m_doTaskImplIndex;
};

MyTask::MyTask() :
  //...
  m_doTaskImplIndex(metaObject()->indexOfMethod("doTaskImpl"))
  //...
{}

void MyTask::doTask( int param )
{
  metaObject()->method(m_doTaskImplIndex).invoke(this, Q_ARG( int, param ) );
}

Answer 3

我怀疑 MyTask 存在错误。如果我正确理解了 Qt 内部结构，那么


moveToThread(&m_thread);
将失败。

如果 parent 不为 0，

Answer 4

那么，将它们全部包装到一个漂亮的类中怎么样？
我还添加了一个槽 finishPlease，它将作为消息待办事项列表中的最后一个元素添加，并在主程序实际处理完所有待处理消息后才可以终止它，并向主程序提供反馈。

class Threaded : public QObject
{
    Q_OBJECT
public:
    Threaded() {
        thread = new QThread(this);
        this->moveToThread(thread);
        connect(thread, SIGNAL(started()), this, SLOT(init()), \
                                                  Qt::QueuedConnection);
        thread->start();
    }

    virtual ~Threaded() {
        thread->exit();
        thread->wait();
        delete thread;
    }

signals:
    void okayKillMe();

public slots:
    virtual void init() = 0;
    void finishPlease() {emit okayKillMe();}

protected:
    QThread* thread;
};

class MyClass : public Threaded
{
  Q_OBJECT
public:
    MyClass() { }
    virtual ~MyClass() { }

public slots:
    void init() { }
    void doStuff() { }
    void doOtherStuff(int* data) { }

};