Qtthread, one of many methods of QT multithreading

QThread It seems to be a very difficult thing , Especially signals and slots . The following is only a simple case written during my study .

QThread How to use multithreading

• QThread Class provides a platform independent method of managing threads . stay Qt The main purpose of establishing threads in is to use threads to deal with those time-consuming background operations , For example, a large number of operations , Copy big files , Network transmission, etc .

• Use Qt Framework when developing applications , Use QThread Class can easily and quickly create and manage multithreads .

• Communication between multiple threads can also be used Qt Peculiar “ The signal - Slot ” Mechanism realization .

QThread There are two ways to use ：

1. Inherit QThread class
2. QObject::moveToThread()

Inherit QThread Method

The first method is simple , It's easy to understand , Write a class inheritance QThread class , And rewrite run() function , And generate a ChildThread Example , And call the object's start() function .

Interface （.h）：

#ifndef THREADDLG_H
#define THREADDLG_H
 
#include <QDialog>
#include <QPushButton>
#include "workthread.h"
#define MAXSIZE 5 //MAXSIZE The macro defines the number of threads 
class ThreadDlg : public QDialog
{
    
    Q_OBJECT
 
public:
    ThreadDlg(QWidget *parent = 0);
    ~ThreadDlg();
private:
    QPushButton *startBtn;
    QPushButton *stopBtn;
    QPushButton *quitBtn;
    workThread *myThread[MAXSIZE];		// Create thread pointer array 
public slots:
    void slotStart();						// The slot function is used to start the thread 
    void slotStop();						// The slot function is used to terminate the thread 
};
 
#endif // THREADDLG_H

Interface （.cpp）：

#include "threaddlg.h"
#include <QHBoxLayout>
ThreadDlg::ThreadDlg(QWidget *parent)
    : QDialog(parent)
{
    
    setWindowTitle(tr(" Threads "));
    startBtn = new QPushButton(tr(" Start "));
    stopBtn = new QPushButton(tr(" stop it "));
    quitBtn = new QPushButton(tr(" sign out "));
 
    QHBoxLayout *mainLayout = new QHBoxLayout(this);
    mainLayout->addWidget(startBtn);
    mainLayout->addWidget(stopBtn);
    mainLayout->addWidget(quitBtn);
 
    connect(startBtn,SIGNAL(clicked()),this,SLOT(slotStart()));
    connect(stopBtn,SIGNAL(clicked()),this,SLOT(slotStop()));
    connect(quitBtn,SIGNAL(clicked()),this,SLOT(close()));
}
 
void ThreadDlg::slotStart()
{
    
    for(int i=0;i<MAXSIZE;i++)
    {
    
        myThread[i]=new workThread();	// Create five threads 
    }
    for(int i=0;i<MAXSIZE;i++)
    {
    
        myThread[i]->start();			// Start these five threads 
    }
    startBtn->setEnabled(false);
    stopBtn->setEnabled(true);
}
 
void ThreadDlg::slotStop()
{
    
    for(int i=0;i<MAXSIZE;i++)
    {
    
        myThread[i]->terminate();// End these five threads 
        myThread[i]->wait();// Blocking waiting for processing to end 
    }
    startBtn->setEnabled(true);
    stopBtn->setEnabled(false);
}
 
ThreadDlg::~ThreadDlg()
{
    
 
}

Thread class ：（.h）

#ifndef WORKTHREAD_H
#define WORKTHREAD_H
 
#include <QThread>
 
class workThread:public QThread
{
    
public:
    workThread();
 
protected:
    void run();
};
 
#endif // WORKTHREAD_H

If you want the main thread to pass parameters to the child thread , Constructors can be used to interact with data .

Thread class ：（.cpp）

#include "workthread.h"
#include <QDebug>
#include <QVector>
 
workThread::workThread()
{
    
 
}
 
void workThread::run()
{
    
    QVector<int> nums{
    1,2,4,3,6,4,2,2,23434,554,232,323,54,66};
    int n = nums.size();
    bool isChange = false;
    while (true) {
    
        for(int i = 1;i<n;i++){
    
            for(int j = 0;j<n-i-1;j++){
    
                if(nums[j]>nums[j+1])
                {
    
                    int t = nums[j];
                    nums[j] = nums[j+1];
                    nums[j+1] = t;
                    isChange = true;
                }
            }
            if(!isChange){
    
                break;
            }
        }
 
        for(int &n:nums){
    
            qDebug()<<n<<" ";
        }
    }
}

QObject::moveToThread

To be honest, I don't quite understand this method

1. Define an ordinary QObject Derived class FileWorker, And then the object move To QThread in .
2. Defining a forwarding class is also QObject Subclass , It's called controller, Or call it dummy. The signal slot of the forwarding class and FileWorker Class , In this way, the slot function of the forwarding class is called in the main thread , Or receive the signal OK 了 .
   It probably means through the forwarding class , Can make FileWorker The slot function of class runs properly in the sub thread . At the same time, there is no need to use QMutex To synchronize ,Qt The event loop will automatically handle this .

summary

Recommended ：
stay QThread Subclasses add signals . It's absolutely safe , And it's true （ The thread dependency of the sender doesn't matter ）

What should not be done is ：
call moveToThread(this) function
Specify connection type ： This usually means that you are doing the wrong thing , For example, will QThread The control interface is mixed with the business logic （ This should be placed in a separate object of the thread ）
stay QThread Subclass add slot function ： This means that they will be called on the wrong thread , That is to say QThread The thread of the object , instead of QThread Object managed threads . This requires you to specify the connection type or call moveToThread(this) function
Use QThread::terminate() function

What cannot be done is ：
Exit the program while the thread is still running . Use QThread::wait() Function waits for the thread to end
stay QThread Destroy the object while the thread managed by the object is still running . If you need something “ Self destruction ” The operation of , You can take finished() The signal is the same as deleteLater() Slots connected

Reference resources ：https://blog.csdn.net/zb872676223/article/details/22718087