问题描述：

Question

我有一个更大的项目，带有GUI，我想在后台管理一些文件。我已经为此任务实现了一个新线程，并且在运行时，一切正常。但是，一旦我退出应用程序，visual-leak-detector就会发现3-7个内存泄漏。

我分离了线程代码并创建了一个新项目，以最少的代码示例进行检查，但是我仍然无法解决问题。

我认为这与主程序的事件循环有关。也许循环不会处理最后的事件以删除我的线程类和线程本身。因为我停止并退出了析构函数中的线程。但是我不确定这一点。

这是我的最小代码： threadclass.hpp：

#include <QObject>
#include <QDebug>

class ThreadClass : public QObject {
    Q_OBJECT

public:
    explicit ThreadClass() {}
    virtual ~ThreadClass(){
        qDebug() << "ThreadClass Destructor";
    }

signals:
    // emit finished for event loop
    void finished();

public slots:
    // scan and index all files in lib folder
    void scanAll(){
        for(long i = 0; i < 10000; i++){
            for (long k = 0; k < 1000000; k++);
            if(i%500 == 0)
                qDebug() << "thread: " << i;
        }
    }
    // finish event loop and terminate
    void stop(){
        // will be processed after scanall is finished
        qDebug() << "STOP SIGNAL --> EMIT FINSIHED";
        emit finished();
    }
};

threadhandler.hpp：

#include <QObject>
#include <QThread>
#include "threadclass.hpp"

class ThreadHandler : public QObject {
    Q_OBJECT

public:
    explicit ThreadHandler(QObject *parent = 0) : parent(parent), my_thread(Q_NULLPTR) {}

    virtual ~ThreadHandler() {
        // TODO Check!
        // I think I don't have to delete the threads, because delete later
        // on finish signal. Maybe I just have to wait, but then how do I
        // check, if thread is not finished? Do I need to make a bool var again?

        if (my_thread != Q_NULLPTR && my_thread->isRunning())
        {
            emit stopThread();
            //my_thread->quit();
            my_thread->wait();
            //delete my_thread;
        }

        qDebug() << "ThreadHandler Destructor";
        my_thread->dumpObjectInfo();
    }

    void startThread(){
        if (my_thread == Q_NULLPTR)
        {
            my_thread = new QThread;
            ThreadClass *my_threaded_class = new ThreadClass();
            my_threaded_class->moveToThread(my_thread);

            // start and finish
            QObject::connect(my_thread, &QThread::started, my_threaded_class, &ThreadClass::scanAll);
            QObject::connect(this, &ThreadHandler::stopThread, my_threaded_class, &ThreadClass::stop);

            // finish cascade
            // https://stackoverflow.com/a/21597042/6411540
            QObject::connect(my_threaded_class, &ThreadClass::finished, my_threaded_class, &ThreadClass::deleteLater);
            QObject::connect(my_threaded_class, &ThreadClass::destroyed, my_thread, &QThread::quit);
            QObject::connect(my_thread, &QThread::finished, my_thread, &QThread::deleteLater);

            my_thread->start();
        }
    }

signals:
    void stopThread();

private:
    QObject *parent;
    QThread* my_thread;
};

main.cpp非常糟糕，但似乎可以很好地模拟我的主程序的行为：

#include <QCoreApplication>
#include <QTime>
#include <QDebug>
#include "threadhandler.hpp"

#include <vld.h>

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

    ThreadHandler *th = new ThreadHandler();
    th->startThread();

    // wait (main gui programm)
    QTime dieTime= QTime::currentTime().addSecs(5);
    while (QTime::currentTime() < dieTime) {
        QCoreApplication::processEvents(QEventLoop::AllEvents, 100);
    }

    qDebug() << "DELETE TH";
    delete th;
    qDebug() << "FINISH ALL EVENTS";
    QCoreApplication::processEvents(QEventLoop::AllEvents, 500);
    qDebug() << "QUIT";
    QCoreApplication::quit();
    qDebug() << "CLOSE APP";
    // pause console
    getchar();
//    return a.exec();
}

这是VLD的输出：

WARNING: Visual Leak Detector detected memory leaks!
...
turns out this is very boring and uninteresting
...
Visual Leak Detector detected 3 memory leaks (228 bytes).
Largest number used: 608 bytes.
Total allocations: 608 bytes.
Visual Leak Detector is now exiting.
The program '[8708] SOMinimalExampleThreads.exe' has exited with code 0 (0x0).

更新1：我在qDebug() << "ThreadClass Destructor";的析构函数中添加了ThreadClass，新的输出如下所示：

...
thread:  9996
thread:  9997
thread:  9998
thread:  9999
ThreadHandler Destructor
FINISH ALL EVENTS
CLOSE APP

现在很明显，我的线程类的析构函数从未被调用过，因此会在void中丢失。但是，为什么这不起作用？

QObject::connect(my_threaded_class, &ThreadClass::finished, my_threaded_class, &ThreadClass::deleteLater);

更新2：我在ThreadHandler中发现了一个问题：

emit stopThread();
my_thread->quit(); // <-- stops the event loop and therefore no deletelater
my_thread->wait();

我删除了my_thread->quit()，现在调用了ThreadClass的析构函数，但是my_thread->wait()从未完成。

Answer 1

我发现my_thread->wait()函数阻止了事件循环，因此退出和deleteLater级联从未完成。 ~~我用另一种等待完成线程的方法解决了这个问题：~~

removed

这是Mike新实施的解决方案。这非常容易实现，我只需要在my_threaded_class::stop类中更改与threadhandler的连接。

#include <QObject>
#include <QThread>
#include "threadclass.hpp"

class ThreadHandler : public QObject {
    Q_OBJECT

public:
    explicit ThreadHandler(QObject *parent = 0) : parent(parent), my_thread(Q_NULLPTR) {}

    virtual ~ThreadHandler() {

        if (my_thread != Q_NULLPTR && my_thread->isRunning())
        {
            my_thread->quit();
            my_thread->wait();
        }

        qDebug() << "ThreadHandler Destructor";
    }

    void startThread(){
        if (my_thread == Q_NULLPTR)
        {
            my_thread = new QThread;
            ThreadClass *my_threaded_class = new ThreadClass();
            my_threaded_class->moveToThread(my_thread);

            // start and finish
            QObject::connect(my_thread, &QThread::started, my_threaded_class, &ThreadClass::scanAll);
            // https://stackoverflow.com/questions/53468408
            QObject::connect(my_thread, &QThread::finished, my_threaded_class, &ThreadClass::stop);

            // finish cascade
            // https://stackoverflow.com/a/21597042/6411540
            QObject::connect(my_threaded_class, &ThreadClass::finished, my_threaded_class, &ThreadClass::deleteLater);
            QObject::connect(my_threaded_class, &ThreadClass::destroyed, my_thread, &QThread::quit);
            QObject::connect(my_thread, &QThread::finished, my_thread, &QThread::deleteLater);

            my_thread->start();
        }
    }

signals:
    void stopThread();

private:
    QObject *parent;
    QThread* my_thread;
};

Answer 2

问题描述：

当ThreadHandler的析构函数从主线程发出stopThread时，Qt通过将事件发布到工作线程的事件循环（又称为队列）中来调用连接的插槽（&ThreadClass::stop）。连接）。这意味着在发出此信号时，工作人员的事件循环需要准备就绪以接收新事件（因为您依靠它来执行适当的清理）。但是，正如您已经发现的那样，对thread->quit()的调用可能会导致事件循环比期望的更早退出（在辅助线程调用ThreadClass::stop之前，因此信号{{1 }}不会发出）。您可能想要检查这个最小示例的输出，该示例重现了我正在谈论的行为：

ThreadClass::finished

在我的机器上，这是可能的输出：

#include <QtCore>

/// lives in a background thread, has a slot that receives an integer on which
/// some work needs to be done
struct WorkerObject : QObject {
  Q_OBJECT
public:
  using QObject::QObject;
  Q_SLOT void doWork(int x) {
    // heavy work in background thread
    QThread::msleep(100);
    qDebug() << "working with " << x << " ...";
  }
};

/// lives in the main thread, has a signal that should be connected to the
/// worker's doWork slot; to offload some work to the background thread
struct ControllerObject : QObject {
  Q_OBJECT
public:
  using QObject::QObject;
  Q_SIGNAL void sendWork(int x);
};

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

  QThread thread;
  WorkerObject workerObj;
  workerObj.moveToThread(&thread);
  // quit application when worker thread finishes
  QObject::connect(&thread, &QThread::finished, &a, &QCoreApplication::quit);
  thread.start();

  ControllerObject controllerObj;
  QObject::connect(&controllerObj, &ControllerObject::sendWork, &workerObj,
                   &WorkerObject::doWork);

  for (int i = 0; i < 100; i++) {
    QThread::msleep(1);
    // call thread.quit() when i is equal to 10
    if (i == 10) {
      thread.quit();
    }
    controllerObj.sendWork(i);
  }
  return a.exec();
}

#include "main.moc"

请注意，尽管在主线程的第十次迭代中调用了working with 0 ... working with 1 ... working with 2 ... working with 3 ...，但工作线程可能不会处理在退出调用之前收到的所有消息（并且我们得到的值为thread.quit()作为工作程序处理的最后一个值）。^*

解决方案：

实际上，Qt提供了一种规范的方法来退出工作线程并执行必要的清理，因为信号3是在special way中处理的：

发出此信号时，事件循环已经停止运行。 除了延迟删除事件外，该线程中将不再处理其他事件。 此信号可以连接到QObject :: deleteLater（），以释放该线程中的对象。

这意味着您可以使用QThread::finished（与您以前的操作方式相同），但是只需添加：

thread->quit()

到您的connect(my_thread, &QThread::finished, my_threaded_class, &ThreadClass::stop);，然后从析构函数中删除不必要的startThread。

^*在文档中找不到详细解释此行为的页面，因此，我提供了这个最小的示例来解释我在说什么。

程序并行QThread在应用程序退出时造成内存泄漏

2 个答案:

问题描述：

解决方案：