QThread不会退出

时间:2015-08-12 17:45:04

标签: c++ multithreading qt

当我关闭我的应用程序时,线程仍然在运行,即使它应该已经结束。以下代码将仅挂在workerThread->wait();行。

主线程

#include "mainwindow.h"
#include "ui_mainwindow.h"

MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)
{
    ui->setupUi(this);

    workerThread = new QThread();
    worker = new Worker();

    worker->moveToThread(workerThread);

    connect(this, SIGNAL(ThreadStopSignal()), worker, SLOT(ThreadStopSlot()));
    connect(this, SIGNAL(StartWorkerSignal()), worker, SLOT(RunSlot()));
    connect(worker, SIGNAL(finished()), workerThread, SLOT(quit()));
    connect(worker, SIGNAL(finished()), worker, SLOT(deleteLater()));
    connect(workerThread, SIGNAL(finished()), workerThread, SLOT(deleteLater()));

    workerThread->start();
    emit(StartWorkerSignal());
    qDebug()<<"Main thread: " << QThread::currentThreadId();
}

MainWindow::~MainWindow()
{
    qDebug() << "Asking threads to exit" << QThread::currentThreadId();
    emit(ThreadStopSignal());

    workerThread->wait();

    qDebug() << "thread is dead";
    delete ui;
}

工人实施

#include "worker.h"

#include <QCoreApplication>

Worker::Worker()
{
    allowRun = true;
}

void Worker::RunSlot()
{
    qDebug() << "Starting";
    int i = 0;
    while(allowRun)
    {
        QThread::msleep(1000);
        QCoreApplication::processEvents();
        qDebug() << i++ << QThread::currentThreadId();
    }
    emit finished();
    qDebug() << "Done counting";
}

void Worker::ThreadStopSlot()
{
    allowRun = false;
    qDebug() << "Ending HID WORKER" << QThread::currentThreadId();
}

典型的运行会产生以下输出(Qt 5.1.1 clang x86_64)*:

Main thread:  0x7fff743b2300 
Starting 
0 0x10b6e1000 
1 0x10b6e1000 
2 0x10b6e1000 
3 0x10b6e1000 
4 0x10b6e1000 
5 0x10b6e1000 
6 0x10b6e1000 
7 0x10b6e1000 
8 0x10b6e1000 
9 0x10b6e1000 
10 0x10b6e1000 
11 0x10b6e1000 
Asking threads to exit 0x7fff743b2300 
Ending HID WORKER 0x10b6e1000 
12 0x10b6e1000 
Done counting 

然而,应用程序仍将运行,只是没有UI;它偶尔会崩溃,导致Apple send-crash-report对话框打开。

*是的,我目前仍然使用稍微旧的Qt版本。但是,我已在新版本上测试了这一点,并取得了类似的结果。

1 个答案:

答案 0 :(得分:1)

问题很简单:当你wait线程完成时,你阻止主线程中的事件循环。然而,与此同时,事件循环必须接收workerThread->quit()调用。因此,你有一个僵局。

简单的解决方法是在quit()之前明确wait()线程。您可以通过修复QThread的固有破坏来实现此目的。请参阅下文,了解Thread类的安全实现。然后,您可以简单地在MainWindow的析构函数中破坏该线程。

唉,代码中有一些反模式和伏都教。

  1. workerThreadworker都不应该成为指针。这是过早的悲观化,因为您添加了额外的堆分配和额外的间接层。它毫无意义,并迫使你在没有要求的情况下进行手动内存管理。

  2. threadStopSlot是线程安全的,没有理由从工作线程的事件循环中调用它。你可以直接打电话。执行此操作时,您无需在QCoreApplication::processEvents中致电runSlot。当您这样做时,您重新进入事件循环,并且突然在该线程中运行的所有对象都需要重入,并且必须按此审计。不好主意 - 不要这样做。

  3. 由于您可能希望让事件循环在worker的线程中运行,您应该反转控件:而不是将控件保留在runSlot中,将其保留在事件循环中,并重复调用事件循环runSlot。这就是零超时计时器的习惯用语。

  4. 初始化列表产生了惯用的C ++。使用它们。

  5. emit是指前缀,而不是函数。您emit fooSignal(),而非emit(fooSignal())。这是一个风格问题,但是emit用于文档目的。它仅用于人类消费,当人们没有包裹在额外的括号中时,人们会更容易阅读。如果您不关心文档方面,请不要使用emit。信号是机器生成实现的常规方法。你不需要以任何特殊的方式打电话给他们。

  6. 由于您使用的是Qt 5,因此您应该使用编译时检查的connect语法。这不需要C ++ 11编译器 - 除非你也使用lambdas。

  7. 要求线程在窗口的析构函数中退出可能是一个坏主意,因为当工作线程退出时,主线程中可能还有其他事情需要做 - 需要的东西需要事件循环正在运行。

    窗口被破坏的唯一方法是,如果它具有WA_DeleteOnClose属性,或者您退出主事件循环并在退出main()时破坏窗口。你应该抓住窗口的关闭事件并设置动态,这样只有在完成所有应该完成的事情时才会删除窗口。

  8. 您可以输出线程本身,而不是将线程ID输出到qDebug()。您可以利用线程是对象的事实,并且可以为它们提供人类可读的名称。然后,您不需要手动比较线程ID或地址,只需阅读该主题的名称。

  9. 鉴于上述所有情况,如果您要求我编写代码,请按以下步骤操作。

    首先,可以将工作人员功能抽象为工作人员:

    #include <QtWidgets>
    
    class WorkerBase : public QObject {
       Q_OBJECT
       Q_PROPERTY(bool active READ isActive WRITE setActive)
       QBasicTimer m_runTimer;
       bool m_active;
    protected:
       void timerEvent(QTimerEvent * ev) {
          if (ev->timerId() != m_runTimer.timerId()) return;
          work();
       }
       virtual void workStarted() {}
       virtual void work() = 0;
       virtual void workEnded() {}
    public:
       WorkerBase(QObject * parent = 0) : QObject(parent), m_active(false) {
          setActive(true);
       }
       /// This method is thread-safe.
       bool isActive() const { return m_active; }
       /// This method is thread-safe.
       void setActive(bool active) {
          QObject source;
          QObject::connect(&source, &QObject::destroyed, this, [this,active]{
             // The functor is executed in the thread context of this object
             if (m_active == active) return;
             if (active) {
                m_runTimer.start(0, this);
                workStarted();
             } else {
                m_runTimer.stop();
                workEnded();
             }
             m_active = active;
          }, thread() ? Qt::QueuedConnection : Qt::DirectConnection);
       }
       ~WorkerBase() {
          Q_ASSERT(QThread::currentThread() == thread() || !thread());
          setActive(false);
       }
    };
    

    然后,工人变得坦白:

    class Worker : public WorkerBase {
       Q_OBJECT
       int m_runCount;
    protected:
       void workStarted() Q_DECL_OVERRIDE {
          qDebug() << "Starting" << QThread::currentThread();
       }
       void work() Q_DECL_OVERRIDE {
          QThread::msleep(1000);
          ++ m_runCount;
          qDebug() << m_runCount << QThread::currentThread();
       }
       void workEnded() Q_DECL_OVERRIDE {
          qDebug() << "Finishing" << QThread::currentThread();
          emit finished();
       }
    public:
       Worker(QObject * parent = 0) : WorkerBase(parent), m_runCount(0) {}
       Q_SIGNAL void finished();
    };
    

    最后,我们添加了安全线程实现,以及一个主窗口,它将控制轨迹保存在事件循环中,并让循环运行,直到所有内容都准备就绪,以便窗口被破坏:

    class Thread : public QThread {
       using QThread::run; // final method
    public:
       Thread(QObject * parent = 0) : QThread(parent) {}
       ~Thread() { quit(); wait(); }
    };
    
    class MainWindow : public QMainWindow {
       Q_OBJECT
       Worker m_worker;
       Thread m_workerThread;
       QLabel m_label;
    protected:
       void closeEvent(QCloseEvent * ev) {
          if (m_worker.isActive()) {
             m_worker.setActive(false);
             ev->ignore();
          } else
             ev->accept();
       }
    public:
       MainWindow(QWidget * parent = 0) : QMainWindow(parent),
          m_label("Hello :)\nClose the window to quit.")
       {
          setCentralWidget(&m_label);
          m_workerThread.setObjectName("m_worker");
          m_worker.moveToThread(&m_workerThread);
          connect(&m_worker, &Worker::finished, this, &QWidget::close);
          m_workerThread.start();
          qDebug() << "Main thread:" << QThread::currentThread();
       }
       ~MainWindow() {
          qDebug() << __FUNCTION__ << QThread::currentThread();
       }
    };
    
    int main(int argc, char ** argv)
    {
       QApplication a(argc, argv);
       QThread::currentThread()->setObjectName("main");
       MainWindow w;
       w.show();
       w.setAttribute(Qt::WA_QuitOnClose);
       return a.exec();
    }
    
    #include "main.moc"
    

    请注意,您的方法必须缺少过多的信号/插槽。所有你关心的是当工人对象完成后,你可以关闭窗口并将所有对象撕成碎片。

    请注意,声明顺序很重要。在这方面,C ++的语义不是随机的:顺序具有意义。必须在worker对象之后声明工作线程,因为它们将以相反的顺序被破坏。因此,线程首先被退出并销毁。此时,m_worker->thread() == nullptr并且您可以从任何线程(包括主线程)中销毁该worker。如果工作人员的线程仍然存在则会出错 - 您需要在自己的线程中销毁该工作人员。

    输出:

    Main thread: QThread(0x7fa59b501180, name = "main")
    Starting QThread(0x7fff5e053af8, name = "m_worker")
    1 QThread(0x7fff5e053af8, name = "m_worker")
    2 QThread(0x7fff5e053af8, name = "m_worker")
    3 QThread(0x7fff5e053af8, name = "m_worker")
    Finishing QThread(0x7fff5e053af8, name = "m_worker")
    ~MainWindow QThread(0x7fa59b501180, name = "main")