QThread related problems

I'm having some problems and questions about QThread. 1) When I use QThread->quit(), finished() signal is not emitted.. 2) How is right way to build and finish execution of thread?

1) finished signal code - the header file.

#ifndef MYTHREAD_H
#define MYTHREAD_H

#include <QThread>

class MyThread: public QThread
{
     Q_OBJECT
public:
    explicit MyThread(QObject *parent = 0);

signals:

public slots:
    void finished();

protected:
    void run();

};

#endif // MYTHREAD_H

1) CPP file.

#include "MyThread.h"

MyThread::MyThread(QObject *parent) :
    QThread(parent)
{
}

void MyThread::finished()
{
    //never gets called...
    qDebug() << "Finished.";
}

void MyThread::run()
{
    connect(this, SIGNAL(finished()), this, SLOT(finished()), Qt::DirectConnection);
    this->exec();
}

I'm building it with this:

MyThread *mThread = new MyThread(this); //What does parent do/mean ?
mThread->start();
Sleep(5000); //Windows.
mThread->quit(); //Finish thread.

I even don't understand what Qt::DirectConnection does, I already read documentation, but I don't really get it how and when to use Direct/Queued connections.

Another questions that came to my mind just now.

1) How can I finish and cleanup thread from self? (I mean, thread should quit by itself and do cleanup.)

2) How to proper why of creating/running new thread and why?

Thank you.

Solution

Don't sub-class QThread. Instead, create a worker object (that inherits QObject), create a QThread, then call the moveToThread() method on your worker object.

class Worker : public QObject
{
  Q_OBJECT
public:
  Worker( QObject * parent = 0 )
    : QObject( parent )
  {
    connect( this, SIGNAL(done()), \
             this, SLOT(deleteLater())
            );
  }

public slots:
  void doWork() { // work, work }

signals:
  void done();  // emit this when you're finished with the work
};

// in your main function (or wherever)
QThread * thread = new QThread();
Worker * w = new Worker();
w->moveToThread( thread );
thread->start();
// clean up your thread
QObject::connect( w, SIGNAL(destroyed()), thread, SLOT(quit()) );
QObject::connect( thread, SIGNAL(finished()), thread(deleteLater()) );

// at some point, emit a signal connected to your workers 'doWork()' slot.
// when the work is finished, the worker and thread will both clean themselves up.

Edit: What if I'm using an older version of Qt?

In recent Qt releases, the default implementation of the QThread::run() method is to call exec(), which starts the thread's event loop. If you're supporting an older version of Qt, you do need to subclass QThread in order for the above code to work.

class MyThread : public QThread
{
  void run() { exec(); }
};

Then, just use MyThread instead of QThread, and all of the above still applies. In this case, it makes perfect sense to subclass QThread because you're creating a specialized thread class (one that runs its own event loop when you call start()).

As for thread clean-up, the above still applies.

QObject::connect( thread, SIGNAL(finished()), thread, SLOT(deleteLater()) );

When you call MyThread::quit(), the event loop will return, run() will return, then the thread object emits the finished() signal. Since the MyThread object actually lives in the main event loop, the deleteLater() slot invocation will still be delivered.