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（），那么它将由主线程执行。对于某些任务，我想强制执行活动对象的线程，即使直接调用slot方法。

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

我怎么能这样做？

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

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) { }

};

调用插槽方法没有连接？

4 个答案: