我不确定为什么我的QThread模式被阻止

Question

I've seen many posts and articles on QThread and moving QObjects between QThreads but alas, its still causing me headaches. This is the pattern I'm trying to adopt:

#include "connectionthread.h"
#include <cassert>

ConnectionThread::ConnectionThread(ConnectionPtr const &connectionPtr) :
                               worker(NULL),
                               m_connectionPtr(connectionPtr)
{
    connect(this, SIGNAL(executeSignal()), this, SLOT(loginProcess()));
}

void
ConnectionThread::start()
{
    if(worker) {
        if(worker->isRunning()) {
            worker->quit();
        }
        delete worker;
    }
    worker = new QThread;
    connect(worker, SIGNAL(started()), this, SLOT(run()));
    worker->start();
}

void
ConnectionThread::run()
{
    emit executeSignal();
}

void
ConnectionThread::loginProcess()
{
    m_connectionPtr->Connect();
}

Now an instance of this is created in the main GUI thread, yet when loginProcess is finally called, it blocks until completion which causes my app's GUI to hang. Note, no difference is observed if I put the logic code directly into the run function and omit the signal like as follows:-

void
ConnectionThread::run() 
{
    m_connectionPtr->Connect();
}

So I assumed that I need to move 'this' to the thread named worker, something like:

void
ConnectionThread::start()
{
    if(worker) {
        if(worker->isRunning()) {
            worker->quit();
        }
        delete worker;
    }
    worker = new QThread;
    this->moveToThread(worker);
    connect(worker, SIGNAL(started()), this, SLOT(run()));
    worker->start();
}

but this gives me

QObject: Cannot create children for a parent that is in a different thread.

I'm not sure why this is the case however since an instance of ConnectionThread is created and its start function is called from another thread. Let's call this other thread GuiThread. This means that GuiThread has control so should be able to transfer ownership of the ConnectionThread instance to the worker thread.

One final possibility which I haven't fully explored yet is the possibility of moving m_connectionPtr to the worker thread..

Any thoughts on the above pattern, how I might improve it, and generally how I can prevent it from blocking?

Answer 1

EDIT 1: The following was my proposed solution but it doesn't actually work as expected because the finished() signal is never being emitted by worker

EDIT 2: fixed the finished signal being triggered but I still can't move m_connectionPtr back to the main thread within the moveConnectionPtrBack. Gives error "QObject::moveToThread: Current thread (0x102900380) is not the object's thread (0x10493b740). Cannot move to target thread (0x102900380)"

So, I think I've figured out what to do: the solution it seems was to transfer thread ownership of the ConnectionPtr to the worker thread:

#include "connectionthread.h"

ConnectionThread::ConnectionThread(ConnectionPtr const &connectionPtr) :
                               worker(NULL),
                               m_connectionPtr(connectionPtr)
{
    // EDIT 2 added bit -- m_connectionPtr sends signal when work finished
    connect(m_connectionPtr.data(), 
            SIGNAL(connectFinishedSignal()), this, SLOT(quitThread()));
}

void
ConnectionThread::start()
{
    if(worker) {
        if(worker->isRunning()) {
            worker->quit();
        }
        delete worker;
    }
    worker = new QThread;
    m_connectionPtr->moveToThread(worker);
    connect(worker, SIGNAL(started()), m_connectionPtr.data(), SLOT(Connect()));
    connect(worker, SIGNAL(finished()), this, SLOT(moveConnectionPtrBack()));
    worker->start();
}

void
ConnectionThread::moveConnectionPtrBack()
{
    // this call failing still
    m_connectionPtr->moveToThread(QApplication::instance()->thread());
}

// EDIT 2 added bit; quitting causes worker to send finished signal() which causes
// correct triggering of moveConnectionPtrBack() function
void
ConnectionThread::quitThread()
{
    worker->quit();
}

(Note m_connectionPtr is a shared ptr to a 'Connection' which itself is derived from a QObject but has no parent; likewise ConnectionThread is derived from a QObject but again, has no parent).

Since m_connectionPtr is also used by other threads in future, I also had to move it back again to the main thread as shown by the moveConnectionPtrBack slot.

Seems to do the trick but overall is not entirely bug-free.