我想在 Qt 5.3 中正确地销毁一个 QThread。

到目前为止我有:

MyClass::MyClass(QObject *parent) : QObject(parent) {
    mThread = new QThread(this);
    QObject::connect(mThread, SIGNAL(finished()), mThread, SLOT(deleteLater()));
    mWorker = new Worker(); // inherits from QObject
    mWorker->moveToThread(mThread);
    mThread->start();
}

MyClass::~MyClass() {
    mThread->requestInterruption();
}

我的问题是在一天结束时我仍然得到:

QThread: Destroyed while thread is still running

最佳答案

安全线程

在 C++ 中，类的正确设计是可以随时安全地销毁实例。几乎所有 Qt 类都以这种方式运行，但 QThread 不是。

这是您应该改用的类:

// Thread.hpp
#include <QThread>
public Thread : class QThread {
  Q_OBJECT
  using QThread::run; // This is a final class
public:
  Thread(QObject * parent = 0);
  ~Thread();
}

// Thread.cpp
#include "Thread.h"
Thread::Thread(QObject * parent): QThread(parent)
{}

Thread::~Thread() {
  quit();
  #if QT_VERSION >= QT_VERSION_CHECK(5,2,0)
  requestInterruption();
  #endif
  wait();
}

它会表现得很好。

QObject 成员不需要在堆上

另一个问题是Worker对象会被泄露。不要将所有这些对象都放在堆上，只需让它们成为 MyClass 或其 PIMPL 的成员即可。

成员声明的顺序很重要，因为成员将按照相反的声明顺序被销毁。因此，MyClass 的析构函数将按顺序调用:

1. m_workerThread.~Thread() 此时线程完成并消失，m_worker.thread() == 0。

2. m_worker.~Worker 由于该对象是无线程的，因此在任何线程中销毁它都是安全的。

3. ~QObject

因此，将 worker 及其线程作为 MyClass 的成员:

class MyClass : public QObject {
  Q_OBJECT
  Worker m_worker;          // **NOT** a pointer to Worker!
  Thread m_workerThread;    // **NOT** a pointer to Thread!
public:
  MyClass(QObject *parent = 0) : QObject(parent),
  // The m_worker **can't** have a parent since we move it to another thread.
  // The m_workerThread **must** have a parent. MyClass can be moved to another
  // thread at any time.
    m_workerThread(this)
  {
    m_worker.moveToThread(&m_workerThread);
    m_workerThread.start();
  }
};

而且，如果你不想在接口(interface)中实现，同样使用 PIMPL

// MyClass.hpp
#include <QObject>
class MyClassPrivate;
class MyClass : public QObject {
  Q_OBJECT
  Q_DECLARE_PRIVATE(MyClass)
  QScopedPointer<MyClass> const d_ptr;
public:
  MyClass(QObject * parent = 0);
  ~MyClass(); // required!
}

// MyClass.cpp
#include "MyClass.h"
#include "Thread.h"

class MyClassPrivate {
public:
  Worker worker;          // **NOT** a pointer to Worker!
  Thread workerThread;    // **NOT** a pointer to Thread!
  MyClassPrivate(QObject * parent);
};

MyClassPrivate(QObject * parent) :
  // The worker **can't** have a parent since we move it to another thread.
  // The workerThread **must** have a parent. MyClass can be moved to another
  // thread at any time.
    workerThread(parent)
{}

MyClass::MyClass(QObject * parent) : QObject(parent),
  d_ptr(new MyClassPrivate(this))
{
  Q_D(MyClass);
  d->worker.moveToThread(&d->workerThread);
  d->workerThread.start();
}

MyClass::~MyClass()
{}

QObject 成员父系

我们现在看到关于任何 QObject 成员的出身的硬性规定。只有两种情况:

1. 如果 QObject 成员未从类中移动到另一个线程，则它必须是类的后代。

2. 否则，我们必须将QObject 成员移动到另一个线程。成员声明的顺序必须保证线程在对象被销毁之前被销毁。如果 无效 以破坏驻留在另一个线程中的对象。

只有满足以下断言才能安全地销毁QObject:

Q_ASSERT(!object->thread() || object->thread() == QThread::currentThread())

线程被销毁的对象变成无线程的，!object->thread() 成立。

有人可能会争辩说我们不“打算”将我们的类移动到另一个线程。如果是这样，那么显然我们的对象不再是 QObject，因为 QObject 具有 moveToThread 方法并且可以随时移动。如果一个类不遵守 Liskov's substitution principle对于它的基类，从基类声明公共(public)继承是错误的。因此，如果我们的类公开继承自QObject，它必须允许自己随时移动到任何其他线程。

QWidget 在这方面有点异常。至少，它应该使 moveToThread 成为 protected 方法。

例如:

class Worker : public QObject {
  Q_OBJECT
  QTimer m_timer;
  QList<QFile*> m_files;
  ...
public:
  Worker(QObject * parent = 0);
  Q_SLOT bool processFile(const QString &);
};

Worker::Worker(QObject * parent) : QObject(parent),
  m_timer(this)  // the timer is our child
  // If m_timer wasn't our child, `worker.moveToThread` after construction
  // would cause the timer to fail.
{}

bool Worker::processFile(const QString & fn) {
  QScopedPointer<QFile> file(new QFile(fn, this));
  // If the file wasn't our child, `moveToThread` after `processFile` would
  // cause the file to "fail".
  if (! file->open(QIODevice::ReadOnly)) return false;      
  m_files << file.take();
}

关于c++ - 如何安全地销毁 QThread？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/25224575/