2017/7/27 11:14:30

---

QThread

• Thread Introduction
  • GUI Thread & Worker Thread
• QThread Usage
• QThread Basic
  • QThread functions
  • Worker Object
  • Subclass QThread
  • QThread operation
• Reference

Thread Introduction

As CPU can run two or more processes, different codes can be run by a single process. The main thread can create other threads, and control each other.

GUI Thread & Worker Thread

Every program has a main thread after starting. In Qt application, we call it as "GUI thread". Qt GUI must run on this thread. And all widgets and some related classes must run on main thread too. Child thread is always called as worker thread, which do some jobs from main threads.

QThread Usage

Lifecycle	Target	Solution
Call Once	Run function in other thread, exit after finishing.	1. QtConcurrent:run() 2. Subclass QRunnable->QThreadPool::start() 3. Subclass QThread->re-implement QThread::run()->QThread::start()
Call Once	Operate all items in a container, try to use all available cores.(Generate Thumbnail)	Use QtConcurrent::map(), QtConcurrent::mapped(), QtConcurrent::mapReduce() to operate data in container.
Call Once	Execute a time-consuming job in a worker thread. During processing, the worker thread will send status to GUI thread. (Process bar)(Cancel, Stop)	Subclass QThread, and emit signal in QThread::run().
Run as event loop	Use an object which lives in other thread to handle jobs. A bi-communication is needed between worker thread and GUI thread. (Cancel, Stop).	Use worker-object, and move it to other thread. Connect signal and slot between threads.

QThread Basic

The QThread class provides a platform-independent way to manage threads. A QThread object manages one thread of control within the program. QThreads begin executing in run(). By default, run() starts the event loop by calling exec() and runs a Qt event loop inside the thread. Some key functions are:

• start(Priority priority = InheritPriority): Begins execution of the thread by calling run().
• wait(unsigned long time = ULONG_MAX): Blocks the thread until either of these conditions is met(1. The thread associated with this QThread object has finished execution. 2. time up )
• run(): The starting point for the thread. You can reimplement this function to facilitate advanced thread management.

Worker object

Use worker objects by moving them to the thread using QObject::moveToThread(). Benefits:

• Signal and slot will be executed in worker thread.
• Run as event loop.

worker code:

#ifndef WORKER_H
#define WORKER_H

#include <QObject>

class Worker : public QObject
{
    Q_OBJECT
public:
    explicit Worker(QObject *parent = 0);

signals:
    void ready();

public slots:
    void doWork();
};

#endif // WORKER_H

---

#include "worker.h"
#include <QDebug>
#include <QThread>

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

void Worker::doWork() {
    qDebug() << "Processing" << QThread::currentThreadId();
    emit ready();
}

controller in main thread, it moves worker :

#ifndef CONTROLLER_H
#define CONTROLLER_H

#include <QObject>
#include <QThread>

class Controller : public QObject
{
    Q_OBJECT
    QThread workerThread;
public:
    explicit Controller(QObject *parent = 0);
    ~Controller();

signals:
    void operate();

public slots:
    void doFinish();

};

#endif // CONTROLLER_H

---

#include "controller.h"
#include <QDebug>
#include <QTimer>
#include "worker.h"
#include <QThread>

Controller::Controller(QObject *parent) :
    QObject(parent) {
    Worker *worker = new Worker;
    worker->moveToThread( &workerThread );

    QTimer::singleShot( 1000, worker, SLOT(doWork()) );
    connect( &workerThread, SIGNAL(finished()), worker, SLOT(deleteLater()) );
    connect( worker, SIGNAL(ready()), this, SLOT(doFinish()) );
    workerThread.start();
}

Controller::~Controller() {
    workerThread.quit();
    workerThread.wait();
}

void Controller::doFinish() {
    qDebug() << "Finish " << QThread::currentThreadId();
}

Subclass QThread

reimplement the run() function:

• Signal and slot will run in the thread which creates itself.
• Easy to implement.

Code:

#include <QApplication>
#include <QDebug>
#include <QThread> 

// sub-class QThread
class WorkerThread : public QThread {
    Q_OBJECT
public:
    void run() {
        qDebug() << currentThreadId();
        emit resultReady();
    }

signals:
    void resultReady();
};

int main( int argc, char **argv ) {
    QApplication app( argc, argv );
    WorkerThread worker;
    worker.start();
    worker.wait();    
    return app.exec();
}

#include "main.moc"

QThread Operation
Now, there will give a process bar example to show:

• Start a QThread
• Communicate with main thread
• Cancel a QThread
• Pause/Continue a QThread

Worker thread:

#ifndef WORKERTHREAD_H
#define WORKERTHREAD_H

#include <QThread>
#include <QMutex>
#include <QMutexLocker>
#include <QWaitCondition>

class WorkerThread : public QThread
{
    Q_OBJECT
public:
    explicit WorkerThread(QObject *parent = 0)
        :QThread( parent ), m_bStopped( false ), m_bPause( false ) {}

    ~WorkerThread() {
        stop(); // Qt 5.x: requestInterruption();
        quit();
        wait();
    }

    void pause() {
        // works as toggled way
        QMutexLocker locker( &m_mutex );
        m_bPause = !m_bPause;
        if ( !m_bPause ) {
            // wakeAll
            m_pauseCondition.wakeAll();
        }
    }

    void stop() {
        QMutexLocker locker( &m_mutex );
        m_bStopped = true;
        if ( m_bPause ) {
            // wake pause condition if the thread is waiting
            m_bPause = false;
            m_pauseCondition.wakeAll();
        }
    }

signals:
    void resultReady( int value );

protected:
    virtual void run() Q_DECL_OVERRIDE {
        int nValue = 0;
        {
            QMutexLocker locker( &m_mutex );
            // reset the state
            m_bStopped = false;
            m_bPause = false;
        }

        // Qt 5.x: while ( !isInterruptionRequested() && nValue <= 100 )
        while ( nValue <= 100 ) {
            msleep( 50 );
            resultReady( nValue );
            nValue ++;

            {
                QMutexLocker locker( &m_mutex );
                if ( m_bStopped ) {
                    break;
                }
            }

            {
                QMutexLocker locker(&m_mutex);
                if (m_bPause) {
                    m_pauseCondition.wait( &m_mutex );
                    if ( m_bStopped ) {
                        break;
                    }
                }
            }
        }
    }

private:
    bool m_bStopped;
    bool m_bPause;
    QMutex m_mutex;
    QWaitCondition m_pauseCondition;
};

#endif // WORKERTHREAD_H

Widget class:

#ifndef CUSTOMWIDGET_H
#define CUSTOMWIDGET_H

#include <QWidget>
#include "workerthread.h"

namespace Ui {
class CustomWidget;
}

class CustomWidget : public QWidget
{
    Q_OBJECT
public:
    explicit CustomWidget(QWidget *parent = 0);
    ~CustomWidget();

private slots:
    void startThread();
    void handleResult( int value );
    void onStop();
    void onPause();
    void onFinish();

private:
    Ui::CustomWidget *m_ui;
    WorkerThread m_workerThread;
};

#endif // CUSTOMWIDGET_H

---

#include "customwidget.h"

#include "ui_CustomWidget.h"

CustomWidget::CustomWidget(QWidget *parent) :
    QWidget(parent), m_ui( new Ui::CustomWidget ) {
    m_ui->setupUi( this );
    this->setAttribute( Qt::WA_QuitOnClose );
    connect( m_ui->m_startBtn, SIGNAL(clicked()), this, SLOT(startThread()) );
    connect( m_ui->m_pauseBtn, SIGNAL(clicked()), this, SLOT(onPause()) );
    connect( m_ui->m_stopBtn, SIGNAL(clicked()), this, SLOT(onStop()) );

    // Qt::DirectConnect
    // The slot is invoked immediately when the signal is emitted.
    // The slot is executed in the signalling thread
    // connect( worker, SIGNAL(resultReady(int)), this, SLOT(handleResult(int)), Qt::DirectConnection );
    connect( &m_workerThread, SIGNAL(resultReady(int)), this, SLOT(handleResult(int)) );
    connect( &m_workerThread, SIGNAL(finished()), this, SLOT(onFinish()) );
}

CustomWidget::~CustomWidget() {
    delete m_ui;
}

void CustomWidget::startThread() {
    if ( !m_workerThread.isRunning() ) {
        m_workerThread.start();
        m_ui->m_startBtn->setEnabled( false );
        m_ui->m_pauseBtn->setEnabled( true );
        m_ui->m_stopBtn->setEnabled( true );
    }
}

void CustomWidget::handleResult( int value ) {
    m_ui->m_processBar->setValue( value );
}

void CustomWidget::onStop() {
    if ( m_workerThread.isRunning() ) {
        m_ui->m_startBtn->setEnabled( true );
        m_ui->m_pauseBtn->setEnabled( false );
        m_ui->m_stopBtn->setEnabled( false );
        m_workerThread.stop();
    }
}

void CustomWidget::onPause() {
    if ( m_workerThread.isRunning() ) {
        m_workerThread.pause();
    }
}

void CustomWidget::onFinish() {
    m_ui->m_startBtn->setEnabled( true );
    m_ui->m_pauseBtn->setEnabled( false );
    m_ui->m_stopBtn->setEnabled( false );
}

Reference

• QThread class
• QThread basic 1
• QThread basic 2
• QThread further