Работа с QTimer, QThread и Progress Bar

Question

Я хотел бы использовать расчет отдельно от Ui-потока. Метод расчета - приватный слот MainWindow Метод. Во время вычислений происходит постепенный перенос рассчитанных данных в объект OutputData - поле окна ProgressBar. Поток, в котором выполняются вычисления, также является полем главного окна.

Конструктор главного окна, в котором создается поток, а начало расчета связано с началом потока:

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

calculation = new QThread(this);

settings.setToDefault();
outputData.setToDefault();
calculationDone = false;

connect(calculation, SIGNAL(started()), this, SLOT(calculate()));

ui->results_display->setText("Загрузите <b>параметры</b> и начинайте расчёты!");
}

Метод с помощью кнопки, запуск потока и модальное окно с ProgressBar:

void MainWindow::on_calculate_button_clicked() {
ui->results_display->clear();
ui->results_display2->clear();

calculation->start();

///TODO QProgressDialog

ProgressDialog progressDialog(&outputData, this);
progressDialog.setModal(true);
progressDialog.exec();

if (progressDialog.result() == QDialog::Rejected) {
    calculation->terminate();
    QMessageBox::critical(this, "Результат", "Расчёт был остановлен!");
} else {
    if (progressDialog.result() == QDialog::Accepted) {
        calculation->quit();
        QMessageBox::about(this, "Результат", "Готово!");
        }
    }
}

Модальный оконный конструктор устанавливает параметры ProgressBar, создает таймер и устанавливает связь между таймером и методом обновления:

ProgressDialog::ProgressDialog(OutputData *outputData, QWidget *parent) :
QDialog(parent),
ui(new Ui::ProgressDialog) {
ui->setupUi(this);

data = outputData;

ui->quantity_label->setText("0");
ui->progressBar->setMinimum(0);
ui->progressBar->setMaximum(static_cast<int>(data->outputSettings.aircraftQuantity));

timer = new QTimer(this);
timer->setSingleShot(false);
connect(timer, SIGNAL(timeout()), this, SLOT(update()));
timer->start(50);
}

Метод обновления ProgressBar:

void ProgressDialog::update() {
unsigned long aircraftsDone = data->results.size() + data->unprocessedAircrafts.size();
ui->progressBar->setValue(static_cast<int>(aircraftsDone));
ui->aircraftQunatityDone_label->setText(QString::number(aircraftsDone));
ui->progressBar->repaint();

if (aircraftsDone == data->outputSettings.aircraftQuantity) {
    accept();
   }
}

Расчеты в настоящее время работают хорошо, но информация о прогрессе не рисуется и не обновляется.

Answer 1

Это пример кода для ответа Ратин и ссылка .

mainwindow.h

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>
#include <QThread>
#include "calculationworker.h"
#include "progressdialog.h"

namespace Ui {
class MainWindow;
}

class MainWindow : public QMainWindow
{
    Q_OBJECT

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

private:
    Ui::MainWindow *ui;
    QThread *calculationThread;
    CalculationWorker *calculationWorker;

signals:
    void startCalculation();
    void stopCalculation();

private slots:
    void on_calculate_button_clicked();
};

#endif // MAINWINDOW_H

mainwindow.cpp

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

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

    calculationThread = new QThread( this );
    calculationWorker = new CalculationWorker();

    calculationWorker->moveToThread( calculationThread );

    connect( this, SIGNAL(startCalculation()), calculationWorker, SLOT(calculate()) );
    connect( this, SIGNAL(stopCalculation()), calculationWorker, SLOT(stopCalculation()), Qt::DirectConnection );

    calculationThread->start();
}

MainWindow::~MainWindow()
{
    calculationThread->quit();
    calculationThread->wait();
    delete calculationWorker;
    delete ui;
}

void MainWindow::on_calculate_button_clicked()
{
    ProgressDialog progressDialog( this );
    connect( calculationWorker, SIGNAL(progress(int, int)), &progressDialog, SLOT(progress(int, int)) );
    connect( calculationWorker, SIGNAL(completed()), &progressDialog, SLOT(completed()) );

    emit startCalculation();

    progressDialog.setModal( true );
    progressDialog.exec();

    if ( progressDialog.result() == QDialog::Rejected ) {
        emit stopCalculation();
    } else if ( progressDialog.result() == QDialog::Accepted ) {
        // Accepted
    }
}

calculationworker.h

#ifndef CALCULATIONWORKER_H
#define CALCULATIONWORKER_H

#include <QObject>
#include <QThread> // msleep()

class CalculationWorker : public QObject
{
    Q_OBJECT
public:
    explicit CalculationWorker(QObject *parent = nullptr);

signals:
    void progress( int processed, int quantity );
    void stopped();
    void completed();

public slots:
    void calculate();
    void stopCalculation();

private:
    bool m_stopFlag;
};

#endif // CALCULATIONWORKER_H

calculationworker.cpp

#include "calculationworker.h"

CalculationWorker::CalculationWorker(QObject *parent) : QObject(parent)
{

}

void CalculationWorker::calculate()
{
    m_stopFlag = false;

    int quantity = 1000;
    for ( int i = 0; i < quantity; i++ ) {
        if ( m_stopFlag ) {
            emit stopped();
            return;
        }

        // Do calculation here
        QThread::msleep( 10 );

        emit progress( i, quantity );
    }

    emit completed();
}

void CalculationWorker::stopCalculation()
{
    m_stopFlag = true;
}

progressdialog.h

#ifndef PROGRESSDIALOG_H
#define PROGRESSDIALOG_H

#include <QDialog>

namespace Ui {
class ProgressDialog;
}

class ProgressDialog : public QDialog
{
    Q_OBJECT

public:
    explicit ProgressDialog(QWidget *parent = nullptr);
    ~ProgressDialog();

private:
    Ui::ProgressDialog *ui;

public slots:
    void progress( int processed, int quantity );
    void completed();
};

#endif // PROGRESSDIALOG_H

progressdialog.cpp

#include "progressdialog.h"
#include "ui_progressdialog.h"

ProgressDialog::ProgressDialog(QWidget *parent) :
    QDialog(parent),
    ui(new Ui::ProgressDialog)
{
    ui->setupUi(this);
}

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

void ProgressDialog::progress(int processed, int quantity)
{
    ui->progressBar->setMaximum( quantity );
    ui->progressBar->setValue( processed );
}

void ProgressDialog::completed()
{
    accept();
}

Answer 2

Это еще один пример кода версии, который не генерирует прогресс при вычислении.

mainwindow.h

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>
#include <QThread>
#include "calculationworker.h"
#include "progressdialog.h"

namespace Ui {
class MainWindow;
}

class MainWindow : public QMainWindow
{
    Q_OBJECT

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

private:
    Ui::MainWindow *ui;
    QThread *calculationThread;
    CalculationWorker *calculationWorker;

signals:
    void startCalculation();

private slots:
    void on_calculate_button_clicked();
};

#endif // MAINWINDOW_H

mainwindow.cpp

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

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

    calculationThread = new QThread( this );
    calculationWorker = new CalculationWorker();

    calculationWorker->moveToThread( calculationThread );

    connect( this, SIGNAL(startCalculation()), calculationWorker, SLOT(calculate()) );

    calculationThread->start();
}

MainWindow::~MainWindow()
{
    calculationThread->quit();
    calculationThread->wait();
    delete calculationWorker;
    delete ui;
}

void MainWindow::on_calculate_button_clicked()
{
    ProgressDialog progressDialog( calculationWorker ,this );

    emit startCalculation();

    progressDialog.exec();

    if ( progressDialog.result() == QDialog::Rejected ) {
        // Rejected(Stopped)
    } else if ( progressDialog.result() == QDialog::Accepted ) {
        // Accepted
    }
}

calculationworker.h

#ifndef CALCULATIONWORKER_H
#define CALCULATIONWORKER_H

#include <QObject>
#include <QThread> // msleep()

class CalculationWorker : public QObject
{
    Q_OBJECT
public:
    explicit CalculationWorker(QObject *parent = nullptr);

    int getQuantity();
    int getProcessed();

signals:
    void started();
    void stopped();
    void completed();

public slots:
    void calculate();
    void stopCalculation();

private:
    bool m_stopFlag;
    bool m_stopped;

    int m_processed;
    int m_quantity;
};

#endif // CALCULATIONWORKER_H

calculationworker.cpp

#include "calculationworker.h"

CalculationWorker::CalculationWorker(QObject *parent) : QObject(parent)
{
    m_quantity = 1000;
}

int CalculationWorker::getQuantity()
{
    // Return quantity (data->outputSettings.aircraftQuantity)))
    return m_quantity;
}

int CalculationWorker::getProcessed()
{
    // Return processed (data->results.size() + data->unprocessedAircrafts.size())
    return m_processed;
}

void CalculationWorker::calculate()
{
    m_stopFlag = false;

    emit started();

    // Calculation
    for ( m_processed = 0; m_processed < m_quantity; m_processed++ ) {
        if ( m_stopFlag ) {
            // emit stopped();
            return;
        }

        // Do calculation here
        QThread::msleep( 10 );
    }

    emit completed();
}

void CalculationWorker::stopCalculation()
{
    m_stopFlag = true;
}

progressdialog.h

#ifndef PROGRESSDIALOG_H
#define PROGRESSDIALOG_H

#include <QDialog>
#include <QTimer>
#include "calculationworker.h"

namespace Ui {
class ProgressDialog;
}

class ProgressDialog : public QDialog
{
    Q_OBJECT

public:
    explicit ProgressDialog( CalculationWorker *worker, QWidget *parent = nullptr);
    ~ProgressDialog();

private:
    Ui::ProgressDialog *ui;
    CalculationWorker *m_worker;
    QTimer *m_progressTimer;

public slots:
    void started();
    void update();
};

#endif // PROGRESSDIALOG_H

progressdialog.cpp

#include "progressdialog.h"
#include "ui_progressdialog.h"

ProgressDialog::ProgressDialog( CalculationWorker *worker, QWidget *parent) :
    QDialog(parent),
    ui(new Ui::ProgressDialog),
    m_worker(worker),
    m_progressTimer(new QTimer(parent))
{
    ui->setupUi(this);

    // Connect started signal from worker
    connect( m_worker, SIGNAL(started()), this, SLOT(started()) );

    // Stop calculation by clicking reject button
    connect( this, SIGNAL(rejected()), m_worker, SLOT(stopCalculation()), Qt::DirectConnection );

    // Connect timeout signal to update
    connect( m_progressTimer, SIGNAL(timeout()), this, SLOT(update()) );

    // Stop the timer when the dialog is closed
    connect( this, SIGNAL(finished(int)), m_progressTimer, SLOT(stop()) );
}

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

void ProgressDialog::started()
{
    ui->progressBar->setMaximum( m_worker->getQuantity() );
    m_progressTimer->start( 50 );
}

void ProgressDialog::update()
{
    ui->progressBar->setValue( m_worker->getProcessed() );

    if ( m_worker->getProcessed() == m_worker->getQuantity() ) {
        accept();
    }
}

Answer 3

Это потому, что ваш calculate метод не вызывается в новом потоке.

Чтобы запустить любой метод в новом потоке с использованием QThread, необходимо переместить объект, для которого этот метод является публичным слотом (этот объект должен наследоваться от QObject класса), в экземпляр QThread с использованием QObject::moveToThread, а затем подключите свой метод с сигналом QThread::started. В вашем случае вы просто устанавливаете соединение между слотом calculate в MainWindow и сигналом QThread::started в calculation, поэтому, когда вы вызываете calculation->start(), вы запускаете метод calculate в том же потоке, в котором вы вызывали calculation->start().

Чтобы это исправить, вы должны создать отдельный класс для вашего calculate метода и затем переместить объект этого класса в ваш QThread внутри MainWindow конструктора.

Я рекомендую вам посмотреть пример в ссылка