Qthread simple test understanding

#ifndef QTHREADTEST_H
#define QTHREADTEST_H

#include <QObject>
#include <QThread>

// method 1
class Worker : public QObject
{
    Q_OBJECT
public:
    explicit Worker(QObject *parent = 0);

signals:
    void resultReady(const QString& result);
public slots:
    void slotDoWork(const QString& param);

protected:
    bool event(QEvent *e) Q_DECL_OVERRIDE;
};

class Controller : public QObject {
    Q_OBJECT
public:
    explicit Controller(QObject *parent=0);
    ~Controller();

    void doSomething(const QString& param);
public slots:
    void slotHandleResult(const QString &result);
signals:
    void operate(const QString &param);

private:
    QThread worker_thread_;
};

// method 2
class WorkerThread : public QThread {
    Q_OBJECT
public:
    WorkerThread(QObject *parent = 0);
    ~WorkerThread();

protected:
    void run() Q_DECL_OVERRIDE;
    bool event(QEvent *e) Q_DECL_OVERRIDE;

signals:
    void resultReady(const QString& result);
public slots:
    void slotThreadFinished();
};

class Controller2 : public QObject {
    Q_OBJECT
public:
    Controller2(QObject *parent = 0);
    void doSomething();

public slots:
    void slotHandleResult(const QString &result);
};

#endif // QTHREADTEST_H

#include "qthreadtest.h"
#include <QDebug>
#include <QEvent>

Worker::Worker(QObject *parent) :
    QObject(parent)
{
}

// By default, run() starts the event loop by calling exec() and runs a Qt event loop inside the thread
void Worker::slotDoWork(const QString &param) {
    QString result("done");

    qDebug() << "worker thread id: " << QThread::currentThreadId() << ", then begin sleep 5 secs...";
    QThread::sleep(5);

    emit resultReady(result);
}

bool Worker::event(QEvent *e) {
    if (e->type() == QEvent::DeferredDelete) {
        qDebug() << "thread id: " << QThread::currentThreadId() << ", DeferredDelete";
    }
    return QObject::event(e);
}

Controller::Controller(QObject *parent) : QObject(parent) {
    Worker *worker = new Worker;
    worker->moveToThread(&worker_thread_);
    connect(&worker_thread_, &QThread::finished, worker, &QObject::deleteLater);
    connect(this, &Controller::operate, worker, &Worker::slotDoWork);
    connect(worker, &Worker::resultReady, this, &Controller::slotHandleResult);
    worker_thread_.start();
}

Controller::~Controller() {
    worker_thread_.quit();
    worker_thread_.wait();
}

void Controller::doSomething(const QString& param) {
    emit operate(param);
}

void Controller::slotHandleResult(const QString &result) {
    qDebug() << "thread id: " << QThread::currentThreadId() << ", " << result;
}

///
// WorkerThread & Controller2
/*
void QObject::deleteLater()
{
    QCoreApplication::postEvent(this, new QDeferredDeleteEvent());
}
...
bool QObject::event(QEvent *e)
{
    switch (e->type()) {
    ....
    case QEvent::DeferredDelete:
        qDeleteInEventHandler(this);
        break;
    ....
    }
}
...
void qDeleteInEventHandler(QObject *o)
{
    delete o;
}
*/
WorkerThread::WorkerThread(QObject *parent) : QThread(parent) {

}

WorkerThread::~WorkerThread() {
    qDebug() << "no event loop, thread id: " << QThread::currentThreadId() << ", ~WorkerThread";
}

void WorkerThread::run() {
    QString result("done");

    qDebug() << "worker thread id: " << QThread::currentThreadId() << ", then begin sleep 5 secs...";
    QThread::sleep(5);

    emit resultReady(result);
}

//  If there is no event loop Of thread Use ,  that thread Destroy objects when finished 
//  When returning to the message loop of the main thread , In the main thread event queue Events in are used notify() Method for distribution 
// notify() Distribute the event to the recipient : receiver->event(event),  namely WorkerThread::event(event), Finally call to QObject::event(...)
// first event type = 43 (QEvent::MetaCall), event type = 52 (QEvent::DeferredDelete)
// QEvent::MetaCall(An asynchronous method invocation via QMetaObject::invokeMethod()),  It is mainly used for signal-slot Mechanism 
bool WorkerThread::event(QEvent *e) {    
    if (e->type() == QEvent::DeferredDelete) {
        qDebug() << "no event loop, thread id: " << QThread::currentThreadId() << ", DeferredDelete";
    }
    bool result = QThread::event(e);

    qDebug() << "no event loop, thread id: " << QThread::currentThreadId() << ", after QThread::event(...) with type = " << e->type();

    return result; //QThread::event(e);
}

//  Main thread execution slotThreadFinished
//  call deleteLater Then the message receiver WorkerThread as well as QDeferredDeleteEvent Events are added to the main thread event queue
void WorkerThread::slotThreadFinished() {
    qDebug() << "no event loop, thread id: " << QThread::currentThreadId() << ", thread finished";
    deleteLater();
}

Controller2::Controller2(QObject *parent) : QObject(parent) {

}

void Controller2::doSomething() {
    WorkerThread *thread = new WorkerThread;
    connect(thread, &QThread::finished, thread, &WorkerThread::slotThreadFinished);
    connect(thread, &WorkerThread::resultReady, this, &Controller2::slotHandleResult);
    thread->start();
}

void Controller2::slotHandleResult(const QString &result) {
    qDebug() << "thread id: " << QThread::currentThreadId() << ", " << result;
}

Reference resources ：Qt Assistant - QThread Class