如何在Qt中正确进行异步初始化？

Question

I have the task of initialisation of an object, that is quite long. What is the right way to go about it?

here is the code i have so far (for simplicity, initialisation consists of adding entries to string list only):

#ifndef TASKINITIALIZER_H
#define TASKINITIALIZER_H
#include <QDir>
#include <QThread>
#include <QObject>
#include "task.h"
class TaskInitializer:public QThread
{
    Q_OBJECT
    QDir dir;
    QString msg;
    Task &result;
public:
    TaskInitializer(QString dname, bool png, bool jpg, bool bmp, Task &res);
    ~TaskInitializer();
    const QString& getMessage();
    bool isOk();
private:
    void run();

};

#endif // TASKINITIALIZER_H


#include <QDir>
#include <QDirIterator>
#include "taskinitializer.h"

TaskInitializer::TaskInitializer(QString dname, bool png, bool jpg, bool bmp, Task & res):
    dir(dname),result(res)
{
    QStringList filters;
    if (png)
        filters << "*.png";
    if(jpg)
    {
        filters << "*.jpeg" << "*.jpg";
    }
    if(bmp)
        filters << "*.bmp";
    dir.setNameFilters(filters);
}

TaskInitializer::~TaskInitializer()
{
}

const QString &TaskInitializer::getMessage()
{
    return msg;
}


bool TaskInitializer::isOk()
{
    if (!dir.exists())
    {
        msg = ("Directory does not exist");
        return false;
    }
    if (dir.nameFilters().length() < 1)
    {
        msg = ("No image types chosen");
        return false;
    }
    return true;
}

void TaskInitializer::run()
{
    QDirIterator di(dir,QDirIterator::Subdirectories);
    while(di.hasNext())
    {
        result.addFilename(di.next());
    }
}

The ides is to pass parameters to initialiser instance in constructor, check their validity and then run the initialisation itself. However, initialisation may take long and the application may be stopped abruptly; in this case initialiser should stop its activity properly and be cleaned up.

I have read on several methods of running async tasks, but still haven't understood how to detect the stop signal. As far as i can see, running QRunnable in thread pool or using QtConcurrent::run() does not gives any mechanism of checking whether it is time to stop or not.

Also, i am confused of the subject of how to pass the object being initialised properly to and from initialising task, so that it would be guaranteed to be cleaned up. Same with initialiser; how can it be guaranteed to be cleaned up?

here is the code i currently use to launch initialisation:

_temp = new Task();
TaskInitializer *worker = new TaskInitializer(_directoryName,flags[2],flags[1],flags[0],*_temp);
if (!worker->isOk())
{
    delete _temp;
    _temp = NULL;
    emit logMessage(worker->getMessage());
    return _temp;
}

//clearTempTask();
emit logMessage("New task created");
connect(worker,SIGNAL(finished()),SIGNAL(taskInitialized()));
connect(worker,SIGNAL(finished()),worker,SLOT(deleteLater()));
worker->start();
worker = NULL;

Answer 1

Well, the quick-and-dirty method would be to have a boolean variable (named pleaseStop or something) that the initializer thread checks every so often to see if the main thread has set it to true or not. If the main thread has set it to true, the thread task would see that and abort its initialization routine and exit.

A slightly nicer method would be to break up the initialization task into smaller parts -- eg do 50 milliseconds worth of initialization, then if there is still more initialization left to do, call QTimer::singleShot(0, this, SLOT(DoSomeMore()) and return from the method, such that the DoSomeMore() slot gets called on the next iteration of the Qt event loop, but in the meantime any other pending signals (such as a PleaseQuitNow() type of signal coming in from the main thread, which could be connected to the QThread's quit() slot) would get processed.

In fact, if you keep the time slices short enough, with the second method you may not even need to launch a second thread at all -- the initialization could run in the main thread but GUI events would still get serviced in a relatively timely manner, since they would get interspersed between short DoSomeMore() calls rather than being blocked by a single very lengthy DoEverythingAllInOneGo() call.

As for passing the data object back and forth, simply handing the initializer thread a pointer/reference to the data object is sufficient, as long as you are careful to ensure the following:

1. The main thread shouldn't read or write the data object until the initializer thread has completed its work
2. The main thread must guarantee that the data object will remain valid until after the initializer thread has completed its work (eg don't delete the data object while the initializer thread might still be using it!)