CODEWITHSUNDEEP
c++qt
smallB
smallB

Reputation: 17138

start doesn't invoke run

I'm trying to implement some small app which is a gui app and has some heavy work to do as a one of it's main tasks. Obviously I'm putting this "work" into a separate thread and starting this thread by invoking start fnc on this obj. Unfortunatelly nothing happens. On the other hands when instead of start I invoke implemented fnc run computations are performed as they should although of course in same thread as gui. What to do?
So I have class inheriting QThread: 

class Working_Thread : public QThread
{
    Q_OBJECT
public:
    typedef boost::filesystem3::path path_t;

private:
    bool& cancel_flag_;
    const std::set<path_t>& paths_;
    int search_depth_;
    typedef void (Dir_File_Select_Dialog::*fnc_ptr)(const std::set<path_t>&,int);
    fnc_ptr fnc_;
    Dir_File_Select_Dialog* parent_;
protected:
    void run()
    {

        (parent_->*fnc_)(paths_,search_depth_);
    }
public:

    Working_Thread(bool& cancel_flag,const std::set<path_t>&,int&,fnc_ptr fnc,Dir_File_Select_Dialog* parent);


};

And here is fragment from gui thread when I try to start new thread:

 Working_Thread* working_thread = new Working_Thread(cancel_flag,paths,search_depth,&Dir_File_Select_Dialog::extract_files_,this);
        working_thread->start();//this desn't invoke run fnc

but when I do: 

working_thread->run();//this will perform computations although in gui thread

UPDATE:
Little change I did which now performs computations when using start fnc but it still blocks GUI. 

Working_Thread* working_thread = new Working_Thread(cancel_flag,paths,search_depth,&Dir_File_Select_Dialog::extract_files_,this);
    working_thread->start();//hangs
    working_thread->wait();//when I call wait here computation is performed but GUI is blocked.

Upvotes: 0

Views: 141

Answers (3)

Marc
Marc

Reputation: 184

I don't know how your code is actually done, but as a first step i suggest you to follow the best practice suggested at the end of the new revision of the Qt documentation of QThread :

http://qt-project.org/doc/qt-4.8/QThread.html (look for bottom of this page)

For a similar tutorial you also may check this article: http://mayaposch.wordpress.com/2011/11/01/how-to-really-truly-use-qthreads-the-full-explanation/

Every time i tried to directly make my treatment in a QThread I ended up having big problems with threads (most of time, the treatment beeing done in the caller's tread). This documentation has been added in 4.8 and the examples provided by documentation of previous versions were missleading.

(code copied from the Qt documentation) Consider the following pattern as your default way to use QThread:

class Worker : public QObject
{
Q_OBJECT

public slots:
void doWork() {
/* ... */
}
};

/* ... */
QThread *thread = new QThread;
Worker *worker = new Worker;
//obj is a pointer to a QObject that will trigger the work to start. It could just be this
connect(obj, SIGNAL(startWork()), worker, SLOT(doWork()));
worker->moveToThread(thread);
thread->start();
//obj will need to emit startWork() to get the work going.

Alternatively, you could do:

//based on the same Worker class as above:

/* ... */
QThread *thread = new QThread;
Worker *worker = new Worker;
worker->moveToThread(thread);
thread->start();
QMetaObject::invokeMethod(worker, "doWork", Qt::QueuedConnection);

Upvotes: 1

Flynch
Flynch

Reputation: 84

If you call wait, the GUI is going to be blocked.

If this program hangs when you do a start, it seems that the problem is in this call: (parent_->*fnc_)(paths_,search_depth_); You could place a qDebug call just before and after this call.

Upvotes: 0

nutrina
nutrina

Reputation: 1042

It is normal that the GUI blocks if you call wait() on a thread, because this will wait for the thread to finish, and also you haven't specified any timeout for wait in this case.

Now regarding the initial problem (when you don't call wait()), I have used QThread successfully in similar scenarios. I do not know though what is wrong in your code, but what I would check is if your execution doesn't hang in other places, like in the invocation of

(parent_->*fnc_)(paths_,search_depth_);

So maybe inserting some log / debug message before and after this call, and also in the function that is invoke here might help isolating the problem. At least then you'll know if the run() method is invoked or not. For example:

qDebug() << "In thread.run()";
(parent_->*fnc_)(paths_,search_depth_);
qDebug() << "In thread.run(), calculations are done";

Also I find it suspicious that you perform calculation using a GUI object (Dir_File_Select_Dialog). This is not normal in Qt, Gui objects should normally be used in the GUI thread. Why not implement the calculations directly in run? Or at least move it to a non-GUI object, just to be sure and keep GUI implementations separated from background operations.

Upvotes: 1

Related Questions