如何阻止运行阻塞永远循环的QThread？

Question

I have some rough code that I've been experimenting with:

someserver.cpp (a GUI)

#include "server.h"
#include "ui_server.h"

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

Server::~Server()
{
    delete ui;
}

void Server::onBtnStartClicked()
{
    QThread worker; 
    worker.start(); // Start worker thread that goes into an infinite loop with a blocking call
}

void Server::onBtnExitClicked()
{
    // How do I cleanly stop worker from running?
    QApplication::quit();
}

worker.cpp

#include "worker.h"

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

void Worker::run()
{
    for (;;)
    {
        // a blocking IO call here like pipe, or msgrcv
        // process data received
    }
}

Since the worker thread runs in a forever loop with a blocking IO call, how will I be able to structure this so that when the Stop button is pressed in the GUI thread, the worker thread is stopped cleanly?

Answer 1

You could of course put a boolean value within the for loop in Worker::run() checked every iteration, which breaks on ==true and is set by the gui Stop button. Of course, this won't quit the thread while execution is blocked.

Probably better is to get rid of the for loop and use Qt's signals and slots to setup a callback function, connected to a signal like QIODevice::readyRead() . These will be called only when there is information available in the socket/pipe whatever. Any other time you'll be able to quit the thread with QThread::exit() . You'll need to call QThread::exec() at some point as well to get the event loop going.

Answer 2

in infinity loop paste this code and enjoy...

QTime dieTime = QTime::currentTime().addMSecs(1);
while( QTime::currentTime() < dieTime ) {
    QCoreApplication::processEvents( QEventLoop::AllEvents, 1);
}

don't forget

#include <QCoreApplication>

#include <QTime>

see you

Answer 3

First of all, you should set the parent for Worker to make it a child of another QObject , to clean it right way when the app is done, and create it on heap. ie dynamic way .

Second , simplest way to do what you want is to define slot which will set boolean member of Worker object and check it in each cycle to break endless loop. Don't forget to connect this slot to a right signal.

so you can put in constructor of the Server along the lines

QThread * worker = new QThread (this);
connect (this, SIGNAL(terminator()), worker, SLOT(terminate()));

in Server class declaration:

signals: 
  terminator();

in class Worker :

private: 
    bool terminate_; // don't forget initialize it to false
public slots: 
    void terminate(){terminate_ = true;}

and in the cycle:

if (terminate_) {/* .. do exit things...*/; return; 

after that emit signal terminator() from server whenever you need.

If you will need more complicated management then simple stop, you will probably need to protect your state variable with a mutex.

Answer 4

To stop the worker thread it is necessary to add "stop requested" boolean flag, which should be tested at the beginning of each iteration. Also the synchronization is needed to read/write value of this boolean flag.

Here is the draft version:

class Worker : public QThread {
    public:
        Worker() : stopRequested(false) {}

        void requestStop()
        {
            QMutexLocker locker(&mutex);
            stopRequested = true;
        }

        void run()
        {
            forever
            {
                if (stopRequested())
                    break;

                // a blocking IO call here like pipe, or msgrcv
                // process data received
            }
        }

    private:
        bool stopRequested()
        {
            QMutexLocker locker(&mutex);
            return stopRequested;
        }

        QMutex mutex;
        bool stopRequested;
};

Answer 5

Here you have the explanation of you're problem, i think. When your application will end, you should do something like this :

MyClass::~MyClass()
{
    m_thread->requestStop();
    m_thread->wait(); // Force the thread trying to destroy 
                      // an object of type MyClass, to wait 
                      // the end of the execution of m_thread
    delete m_thread;
}

wait() is the solution for your synchronisation problem. You could also change requestStop() to :

void requestStop()
{
    mutex.lock();
    stopRequested = true;
    mutex.unlock();
    wait();
}

Removing QMutexLocker is important to avoid a Deadlock situation.