Safest way to delete workers when TCP server is closing

[VRonin]

• the connects should be done when thread and workerClient are created
• you forgot the "almost" part.

[dream_captain]

@VRonin
I made a small example illustrating the problem:

threadex.h

#ifndef THREADEX_H
#define THREADEX_H

#include <QThread>
#include <QDebug>

class ThreadEx : public QThread
{
    Q_OBJECT
public:
    explicit ThreadEx(QObject *parent = nullptr) :
        QThread(parent)
    {
        qDebug() << "thread: " << this << "created in: " << QThread::currentThread();
    }
    ~ThreadEx()
    {
        qDebug() << "thread: " << this << "deleted in: " << QThread::currentThread();
    }

};
#endif // THREADEX_H

main.cpp

#include <QApplication>
#include <QWidget>

#include "threadex.h"

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);

    ThreadEx *thread = new ThreadEx;
    QObject::connect(thread, &ThreadEx::finished, thread, &ThreadEx::deleteLater);
    QObject::connect(qApp, &QApplication::aboutToQuit,   thread, &ThreadEx::quit);
    QObject::connect(qApp, &QApplication::aboutToQuit,   []() {
        qDebug() <<  "aboutToQuit()";
    });
    thread->wait();  // don't know why i should block here, but this always returns true

    QWidget  widget;
    widget.show();

    return a.exec();
}

Output:

thread:  ThreadEx(0x768ca0) created in:  QThread(0x605fe0)
aboutToQuit()

ThreadEx::~ThreadEx() is not getting called. How can i be sure that cleanup was successfull and there is no running thread left?

Just for clarification:
QObject::deleteLater() documentation says that The object will be deleted when control returns to the event loop. Does that mean that deletion of all QObjects via deleteLater() is controlled by QApplication main event loop?

[jsulm]

@dream_captain said in Safest way to delete workers when TCP server is closing:

thread->wait();

why do you call wait?

[dream_captain]

@jsulm
To be sure that the thread has finished. I think that wait() is not necessary when we schedule deletion of QThread.

[J.Hilk]

@dream_captain
Good Morning,
wait will always return true, if the thread is not started, and in your example, the thread is not started. you simply call wait on it.

To expand your basic example:

#include <QApplication>
#include <QWidget>

#include "threadex.h"

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);

    ThreadEx *thread = new ThreadEx;
    QObject::connect(thread, &ThreadEx::finished, thread, &ThreadEx::deleteLater);
    QObject::connect(qApp, &QApplication::aboutToQuit,   thread, &ThreadEx::quit);
    QObject::connect(qApp, &QApplication::aboutToQuit,   []() {
        qDebug() <<  "aboutToQuit()";
    });
    thread.start();

....
....

    thread->quit();
    thread->wait();  
    
    QWidget  widget;
    widget.show();

    return a.exec();
}

[dream_captain]

@J.Hilk
Oh, I admit that i simply forget to start the thread. But shouldn't the deletion of thread be handled by QApplication in the snippet below? If i've understood the documentation correctly, there is no need to call quit() and wait() explicitly.

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);

    ThreadEx *thread = new ThreadEx;

    QObject::connect(thread, &ThreadEx::finished, thread, &ThreadEx::deleteLater);
    QObject::connect(qApp, &QApplication::aboutToQuit,   thread, &ThreadEx::quit);
    QObject::connect(qApp, &QApplication::aboutToQuit,   []() {
        qDebug() <<  "aboutToQuit()";
    });
    thread->start();

    QWidget  widget;
    widget.show();

    return a.exec();
}

Still no ThreadEx destructor.

[J.Hilk]

@dream_captain Well, I'm not entierly sure,

I took inspiration from the example in the docs:

class Worker : public QObject
{
    Q_OBJECT
    QThread workerThread;

public slots:
    void doWork(const QString &parameter) {
        // ...
        emit resultReady(result);
    }

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

class Controller : public QObject
{
    Q_OBJECT
    QThread workerThread;
public:
    Controller() {
        Worker *worker = new Worker;
        worker->moveToThread(&workerThread);
        connect(&workerThread, SIGNAL(finished()), worker, SLOT(deleteLater()));
        connect(this, SIGNAL(operate(QString)), worker, SLOT(doWork(QString)));
        connect(worker, SIGNAL(resultReady(QString)), this, SLOT(handleResults(QString)));
        workerThread.start();
    }
    ~Controller() {
        workerThread.quit();
        workerThread.wait();
    }
public slots:
    void handleResults(const QString &);
signals:
    void operate(const QString &);
};

[dream_captain]

Updated example with Worker object.

worker.h

#ifndef WORKER_H
#define WORKER_H
#include <QObject>
#include <QDebug>
#include <QThread>
class Worker : public QObject
{
    Q_OBJECT
public:
    explicit Worker(QObject *parent = nullptr) :
        QObject(parent)
    {
        qDebug() << "worker: " << this << "created in: " << QThread::currentThread();
    }

    ~Worker()
    {
        qDebug() << "worker: " << this << "deleted in: " << QThread::currentThread();
    }
};
#endif // WORKER_H

threadex.h

#ifndef THREADEX_H
#define THREADEX_H
#include <QThread>
#include <QDebug>
class ThreadEx : public QThread
{
    Q_OBJECT
public:
    explicit ThreadEx(QObject *parent = nullptr) :
        QThread(parent)
    {
        qDebug() << "thread: " << this << "created in: " << QThread::currentThread();
    }
    ~ThreadEx()
    {
        qDebug() << "thread: " << this << "deleted in: " << QThread::currentThread();
    }
};
#endif // THREADEX_H

main.cpp

#include <QApplication>
#include <QWidget>

#include "threadex.h"
#include "worker.h"

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);

    ThreadEx *thread = new ThreadEx;

    Worker *worker = new Worker;

    worker->moveToThread(thread);

    QObject::connect(thread, &ThreadEx::finished, thread, &ThreadEx::deleteLater);
    QObject::connect(thread, &ThreadEx::finished, worker, &Worker::deleteLater);


    QObject::connect(qApp, &QApplication::aboutToQuit,   thread, &ThreadEx::quit);
    QObject::connect(qApp, &QApplication::aboutToQuit,   []() {
        qDebug() <<  "aboutToQuit()";
    });
    thread->start();


    QWidget  widget;
    widget.show();

    return a.exec();
}

Output:

thread:  ThreadEx(0x748d90) created in:  QThread(0x606fe0)
worker:  Worker(0x733020) created in:  QThread(0x606fe0)
aboutToQuit()
worker:  Worker(0x733020) deleted in:  ThreadEx(0x748d90)

Looks like QApplication process Worker's deleteLater() fine, but don't want to process ThreadEx's deleteLater().

[jsulm]

@dream_captain said in Safest way to delete workers when TCP server is closing:

But shouldn't the deletion of thread be handled by QApplication in the snippet below?

If you do not start the thread finished() signal will not be emitted and deleteLater() slot will not be called.
So, if you do not delete the thread explicitly using "delete" it will not be deleted.
Who and why should delete it in this case - it does not even have a parent? QApplication does not do memory management.

[dream_captain]

@jsulm
Yeah, i understand (just forget to start thread). In that example thread->start() was called though.
In the last example deletion of ThreadEx object should be handled by application main loop.