Qt/C++ - Lesson 048. QThread — How to work with threads using moveToThread

QObject, потоки, moveToThread, Qt, QThread

In a previous article we are only a little touch to working with threads , and in the version that is more for the customization of thread, although it can be used to perform outside work not directly related to the thread. That is an option with inheritance from QThread and override the method run().

Now we will create ExampleObject class whose objects will be transferred to the individual threads via moveToThread() method and implemented in most of these flows. A useful work will make the slot method run() , which will be defined in this class. What is important, object class will inherit from QObject .

In order to work in the run() method can be performed in cycles, using a while loop, which will operate using variable bool m_running. For the convenience of working with this variable we define it as Q_PROPERTY . But at the end of the work will emit finished() signal.

Work algorithm

1. Create an QThread object and the ExampleObject class object;
2. Connect the signal QThread::started() method to ExampleObject::run() ;
3. Connect the signal ExampleObject::finished() to slot QThread::terminate() , so that on completion of useful work to complete the flow;
4. Set m_running variable to true, to allow the work cycle, or else this method once completed;
5. Run stream using the method start() ;
6. When it is necessary to complete useful work object, set the variable in m_running to false. Running run() method and the flux in which he lives the object will be completed automatically and correctly.

Project structure and appearance of the application

• ThreadLessonTwo.pro - the profile of the project;
• exampleobject.h - header of the object file to be transmitted in a thread;
• exampleobject.cpp - file source object that will be passed in the thread;
• mainwindow.h - header file of the main application window;
• mainwindow.cpp - file source code of the main application window;
• mainwindow.ui - file forms the main application window;
• main.cpp - the file source code to the main function.

Attached are two objects to be determined, and the two streams. With the help of the application interface, we will show some information in the output qDebug() , and will start and stop the thread.

exampleobject.h

To begin, consider the contents of the object header file. In this file, three properties announced Q_PROPERTY :

1. running - it is a variable, by means of which will be implemented in the control cycle a run() method and, accordingly, will affect the completion of the useful work of the object.
2. message - a string that will be sent to output in qDebug() from the main application window
3. message_2 - this is the second line, which will also be displayed in qDebug() , but will also be used for transmission of the second stream.

#ifndef EXAMPLEOBJECT_H
#define EXAMPLEOBJECT_H

#include <QObject>

class ExampleObject : public QObject
{
    Q_OBJECT
    // A property that controls the work of thread
    Q_PROPERTY(bool running READ running WRITE setRunning NOTIFY runningChanged)
    // The first message in the object
    Q_PROPERTY(QString message READ message WRITE setMessage NOTIFY messageChanged)
    // The second message that will be transmitted via a signal/slot to the second object
    Q_PROPERTY(QString message_2 READ message_2 WRITE setMessage_2 NOTIFY message_2Changed)

    bool m_running;
    QString m_message;
    QString m_message_2;
    int count;  

public:
    explicit ExampleObject(QObject *parent = 0);
    bool running() const;
    QString message() const;
    QString message_2() const;

signals:
    void finished();    // The signal, in which we will complete the thread after the end of the run method
    void runningChanged(bool running);
    void messageChanged(QString message);
    void message_2Changed(QString message_2);
    void sendMessage(QString message);

public slots:
    void run(); // Method with payload which can be carried out in a loop
    void setRunning(bool running);
    void setMessage(QString message);
    void setMessage_2(QString message_2);
};

#endif // EXAMPLEOBJECT_H

exampleobject.cpp

All our interest is reduced to the method run() , in which the while loop will increment the counter count and the information will be displayed with the message m_message , m_message_2 and this counter as long as the variable m_running not be exposed to a value of false. At the exit of the loop at the end of execution run() method will be released finished() signal, in which the flow is completed, which will be the object.

#include "exampleobject.h"
#include <QDebug>

ExampleObject::ExampleObject(QObject *parent) :
    QObject(parent),
    m_message(""),
    m_message_2("")
{

}

bool ExampleObject::running() const
{
    return m_running;
}

QString ExampleObject::message() const
{
    return m_message;
}

QString ExampleObject::message_2() const
{
    return m_message_2;
}

// The most important method, which will be carried out "useful" work object
void ExampleObject::run()
{
    count = 0;
    // Variable m_running responsible for the object in the stream.
    // If false, the work is completed
    while (m_running)
    {
        count++;
        emit sendMessage(m_message); 
        qDebug() << m_message << " " << m_message_2 << " " << count;
    }
    emit finished();
}

void ExampleObject::setRunning(bool running)
{
    if (m_running == running)
        return;

    m_running = running;
    emit runningChanged(running);
}

void ExampleObject::setMessage(QString message)
{
    if (m_message == message)
        return;

    m_message = message;
    emit messageChanged(message);
}

void ExampleObject::setMessage_2(QString message_2)
{
    if (m_message_2 == message_2)
        return;

    m_message_2 = message_2;
    emit message_2Changed(message_2);
}

mainwindow.h

The header of the main window of the application declared slots for processing keystrokes to record messages to the objects that will be carried out in the streams, as well as slots for starting and stopping the flow. In addition, we declare two objects ExampleObject class and two objects of QThread class.

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>
#include <QThread>
#include "exampleobject.h"

namespace Ui {
class MainWindow;
}

class MainWindow : public QMainWindow
{
    Q_OBJECT

public:
    explicit MainWindow(QWidget *parent = 0);
    ~MainWindow();

private slots:
    void on_write_1_clicked();  // Slot for writind data from lineEdit_1 to the first object in the first stream
    void on_write_2_clicked();  // Slot for writind data from lineEdit_1 to the second object in the first stream
    void on_start_clicked();   
    void on_stop_clicked();     

private:
    Ui::MainWindow *ui;
    QThread thread_1;       
    QThread thread_2;       
    ExampleObject exampleObject_1;  
    ExampleObject exampleObject_2; 
};

#endif // MAINWINDOW_H

mainwindow.cpp

And now combine all of the previous code in a working application in the source code of the main program window. In the constructor of the class, as has been said in the beginning, you need to connect signals started() of the threads to the slots run() our test objects, and signals the finished(), to the slots terminate() of threads to complete the work streams at completion method run().

Also joined sending message signal exampleObject_1 object to slot installation exampleObject_2 messages. But that information can be transmitted, you need the fifth argument in the connect method to transfer the flag Qt :: DirectConnection, which would establish a direct connection of objects and allows to transmit information through a system of signals and slots .

And for the transfer of objects in the threads necessary to use the method moveToTrhead().

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

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

    connect(&thread_1, &QThread::started, &exampleObject_1, &ExampleObject::run);
    connect(&thread_2, &QThread::started, &exampleObject_2, &ExampleObject::run);

    connect(&exampleObject_1, &ExampleObject::finished, &thread_1, &QThread::terminate);
    connect(&exampleObject_2, &ExampleObject::finished, &thread_2, &QThread::terminate);

    connect(&exampleObject_1, &ExampleObject::sendMessage, &exampleObject_2, &ExampleObject::setMessage_2, Qt::DirectConnection);
    exampleObject_1.moveToThread(&thread_1);    
    exampleObject_2.moveToThread(&thread_2);
}

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

void MainWindow::on_write_1_clicked()
{
    exampleObject_1.setMessage(ui->lineEdit_1->text());
}

void MainWindow::on_write_2_clicked()
{
    exampleObject_2.setMessage(ui->lineEdit_2->text());
}

void MainWindow::on_start_clicked()
{
    exampleObject_1.setRunning(true);
    exampleObject_2.setRunning(true);
    thread_1.start();
    thread_2.start();
}

void MainWindow::on_stop_clicked()
{
    exampleObject_1.setRunning(false);
    exampleObject_2.setRunning(false);
}

Coclusion

As a result, the application can be obtained following the following conclusion qDebug(), which shows the parallel operation of facilities in the streams, as well as the transfer of information from one thread to another.

"thread 1"   ""   11422
"thread 2"   "thread 1"   11446
"thread 1"   ""   11423
"thread 2"   "thread 1"   11447
"thread 1"   ""   11424
"thread 2"   "thread 1"   11448
"thread 1"   ""   11425
"thread 2"   "thread 1"   11449
"thread 1"   ""   11426
"thread 2"   "thread 1"   11450
"thread 1"   ""   11427
"thread 2"   "thread 1"   11451

Download the project can be on the following link: Thread Lesson Two

Video