Qt/C++ - Lektion 048. QThread — So arbeiten Sie mit Threads mithilfe von moveToThread

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

Im vorherigen Artikel haben wir nur Arbeiten mit Streams angesprochen, und in der Version, die mehr dazu dient, den Stream selbst anzupassen, obwohl es verwendet werden kann Nebenarbeiten ausführen, die nichts direkt mit Streams zu tun haben. Das heißt, eine Variante mit Vererbung von QThread und Überschreiben der Methode run() .

Jetzt erstellen wir eine ExampleObject-Klasse, deren Objekte mithilfe der moveToThread() -Methode an separate Threads übertragen und in denselben Threads ausgeführt werden. Und nützliche Arbeit wird von der Slot-Methode run(), erledigt, die in dieser Klasse definiert wird. Wichtig ist, dass die Objektklasse von QObject erbt.

Damit die Arbeit in der run() -Methode zyklisch ausgeführt wird, verwenden wir die while -Schleife, die wir mit der Variablen bool m_running. steuern werden diese Variable definieren wir als * Q_PROPERTY. Nun, wenn die Arbeit abgeschlossen ist, geben wir das Signal finished() * aus.

Arbeitsalgorithmus

Und jetzt wenden wir uns direkt der Arbeit mit dem Stream und dem Objekt zu. Der Arbeitsalgorithmus wird wie folgt sein:

1. Erstellen Sie ein Objekt QThread und ein Objekt der Klasse ExampleObject;
2. Verbinden Sie das Signal QThread::started() mit der Methode ExampleObject::run();
3. Wir verbinden das Signal ExampleObject::finished() mit dem Slot QThread::terminate(), um die Ausführung des Threads zu beenden, wenn nützliche Arbeit abgeschlossen ist;
4. Setzen Sie die Variable m_running auf true , um die Schleife zu aktivieren, andernfalls wird die Methode sofort beendet;
5. Starten Sie den Thread mit der Methode start();
6. Wenn es notwendig ist, die Ausführung der nützlichen Arbeit des Objekts abzuschließen, setzen Sie die Variable m_running auf false. Die Ausführung der Methode run() und des Threads, in dem sich das Objekt befindet, wird automatisch und korrekt beendet.

Projektstruktur und Aussehen der Anwendung

• ThreadLessonTwo.pro - Projektprofil;
• exampleobject.h - Header-Datei des Objekts, das an den Stream übergeben wird;
• exampleobject.cpp - Quellcodedatei des Objekts, das an den Stream übergeben wird;
• mainwindow.h - Header-Datei des Hauptanwendungsfensters;
• mainwindow.cpp - Quellcodedatei für das Hauptanwendungsfenster;
• mainwindow.ui - Formulardatei des Hauptanwendungsfensters;
• main.cpp - Quellcodedatei mit der Hauptfunktion.

Die Anwendung definiert zwei Objekte und zwei Threads. Mithilfe der Anwendungsschnittstelle werden wir einige Informationen festlegen, die in der Ausgabe von qDebug() angezeigt werden, und wir werden auch Threads starten und stoppen.

Der Vorgang zum Erstellen eines Anwendungsfensters wird im Video-Tutorial gezeigt.

Beispielobjekt.h

Sehen wir uns zunächst den Inhalt der Header-Datei des Objekts an. Diese Datei deklariert drei Q_PROPERTY -Eigenschaften:

1. running ist eine Variable, die die Schleife in der run() -Methode steuert und dementsprechend den Abschluss der nützlichen Arbeit des Objekts beeinflusst.
2. Nachricht ist eine Zeichenfolge, die zur Ausgabe an qDebug() aus dem Hauptanwendungsfenster übergeben wird
3. message_2 ist die zweite Zeile, die auch in qDebug() angezeigt wird, aber auch für die Übergabe an den zweiten Stream verwendet wird.

Die Header-Datei deklariert auch die Slot-Methode run(), das Signal finished() und die Variable int count, which

#ifndef EXAMPLEOBJECT_H
#define EXAMPLEOBJECT_H

#include <QObject>

class ExampleObject : public QObject
{
    Q_OBJECT
    // Свойство, управляющее работой потока
    Q_PROPERTY(bool running READ running WRITE setRunning NOTIFY runningChanged)
    // Первое сообщение в объекте
    Q_PROPERTY(QString message READ message WRITE setMessage NOTIFY messageChanged)
    // Второе сообщение, которое будем передавать через сигнал/слот во второй объект
    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();    // Сигнал, по которому будем завершать поток, после завершения метода run
    void runningChanged(bool running);
    void messageChanged(QString message);
    void message_2Changed(QString message_2);
    void sendMessage(QString message);

public slots:
    void run(); // Метод с полезной нагрузкой, который может выполняться в цикле
    void setRunning(bool running);
    void setMessage(QString message);
    void setMessage_2(QString message_2);
};

#endif // EXAMPLEOBJECT_H

Beispielobjekt.cpp

Unser ganzes Interesse gilt der run()-Methode , bei der in der while -Schleife der Zähler count erhöht und Informationen mit der Meldung m_message, angezeigt werden. m_message_2 und der angegebene Zähler bis zum Setzen der Variable m_running auf false . Beim Verlassen der Schleife, wenn die Ausführung der Methode run() abgeschlossen ist, wird das Signal finished() ausgegeben, das den Thread beendet, in dem sich dieses Objekt befinden wird.

#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;
}

// Самый важный метод, в котором будет выполняться "полезная" работа объекта
void ExampleObject::run()
{
    count = 0;
    // Переменная m_running отвечает за работу объекта в потоке.
    // При значении false работа завершается
    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);
}

Hauptfenster.h

Die Header-Datei des Hauptfensters der Anwendung deklariert Slots zum Verarbeiten von Tastendrücken, um Nachrichten an Objekte zu schreiben, die in Threads ausgeführt werden, sowie Slots zum Starten und Stoppen von Threads. Außerdem deklarieren wir zwei Objekte der Klasse ExampleObject und zwei Objekte der Klasse QThread.

#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();  // Слот для записи данных из lineEdit_1 в первый объект первого потока
    void on_write_2_clicked();  // Слот для записи данных из lineEdit_1 во второй объект второго потока
    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

Hauptfenster.cpp

Lassen Sie uns nun den gesamten vorherigen Code zu einer funktionierenden Anwendung im Quellcode des Hauptanwendungsfensters kombinieren. Im Konstruktor dieser Klasse müssen, wie bereits ganz am Anfang erwähnt, die started() -Signale der Threads mit den run() -Slots unserer Testobjekte verbunden werden, und die * finished(), signalisiert den Thread-Slots terminate(), , Threads zu beenden, wenn die Methode run() abgeschlossen ist. *

Wir werden auch das Signal zum Senden einer Nachricht des exampleObject_1 -Objekts an den Nachrichten-Setup-Slot von exampleObject_2 anhängen. Damit die Informationen jedoch übertragen werden können, müssen Sie *Qt::DirectConnection übergeben * Flag als fünftes Argument für die Verbindungsmethode, die eine direkte Verbindung von Objekten herstellt und es Ihnen ermöglicht, die Übertragung von Informationen über das System [Signale und Zeitschlitze] auszuführen (https://evileg.com/en/post/87/ ) .

Um Objekte in Streams zu übertragen, müssen Sie die Methode moveToTrhead(). verwenden.

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

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

    // Запуск выполнения метода run будет осуществляться по сигналу запуска от соответствующего потока
    connect(&thread_1, &QThread::started, &exampleObject_1, &ExampleObject::run);
    connect(&thread_2, &QThread::started, &exampleObject_2, &ExampleObject::run);
    // Остановка потока же будет выполняться по сигналу finished от соответствующего объекта в потоке
    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()
{
    // Остановка потоков через завершение выполнения методов run в объектах
    exampleObject_1.setRunning(false);
    exampleObject_2.setRunning(false);
}

Fazit

Als Ergebnis der Ausführung der Anwendung können Sie die folgende Ausgabe von qDebug() erhalten, die den parallelen Betrieb von Objekten in Threads sowie die Übertragung von Informationen von einem Thread zu einem anderen demonstriert.

"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

Sie können das Projekt unter folgendem Link herunterladen: Thread Lesson Two

Videoanleitung