QT -- thread

Tips ： This is the learning record , If there is an error , Please contact the author , Modest and educated .

---

Preface

Find a partner like the sun , It's worth nothing to help you dry everything .

---

One 、QT Operation thread

1、 By inheritance QThread class , rewrite QThread Class run function , control Run Function to operate a new thread .
2、 By inheritance QObject class , Write the thread operation function in the new class , adopt movetothread() Function to transfer the newly created class to a new thread .

Two 、 Inherit QThread, rewrite run（）

1.mythread class

mythread.h file

#ifndef MYTHREAD_H
#define MYTHREAD_H
#include <QThread>
#include <QDebug>
 
class MyThread : public QThread
{
    
public:
    explicit MyThread(){
    }
 
private:
  void run() override;
private slots:
  void sig_ShowMsg(QString,bool);
 
#endif // MYTHREAD_H

mythread.cpp file

void MyThread::run()
{
    
// Execution of complex functions 
emit sig_ShowMsg(" Send successfully ",true);
}

2.mainwindow

mainwindow.h file

// Define the thread 
MyThread* m_thread;
signals:
    void slt_ShowMsg(QString ,bool );

mainwindow.cpp file

MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)
{
    
    ui->setupUi(this);
    // Declaration thread 
    m_thread = new MyThread;
    // The two are connected with the slot through signals 
    connect(&m_thread,SIGNAL(sig_ShowMsg(QString,bool)),SLOT(slt_ShowMsg(QString ,bool )));
}
// Trigger the thread to start through the button 
void MainWindow::on_btnstart_clicked()
{
    
thread->start();// When using this function, it will automatically call run function 
qDebug()<<"main thread: "<< QThread::currentThreadId();
emit sig_start();
}
// Stop the thread through the button 
void MainWindow::on_btnclose_clicked()
{
    
// End thread 
thread->exit();
thread->deleteLater();
emit sig_Close();
}
void MainWindoe::slt_ShowMsg(QString a,bool b)
{
    
  ui->text->setText("a");
}

The connection between the main thread and the sub thread is through the signal and slot .
Tips ： Only in Run The content of the function is in the new thread , Other functions are in old threads .

3、 ... and 、 Inherit QObject, adopt moveToThread（）

1.MyObject class

// Thread processing object 
#ifndef MYOBJECT_H
#define MYOBJECT_H
#include <QObject>
#include <QThread>
#include <QDebug>
 
class MyObject : public QObject
{
    
    Q_OBJECT
public:
    explicit MyObject(QObject *parent = 0): QObject(parent){
    }
    ~MyObject(){
    }
 
private slots:
    void Start()// Thread handler 
    {
    
        qDebug()<<"obj thread: "<<QThread::currentThreadId();
    }
};
 
#endif // MYOBJECT_H

stay Mainwindow When used in ,

// Defining variables 
MyObject*   obj;
QThread*    thread;
 
// Start thread 
obj = new MyObject;// Thread execution object 
thread = new QThread;
obj->moveToThread(thread);// Move the object to the newly created thread 
connect(thread, &QThread::started, obj, &MyObject::Start);// Bind the start signal of the thread , After the thread starts, it will execute obj Of Start Slot function 
thread->start();
qDebug()<<"main thread: "<<QThread::currentThreadId();
 
// End thread 
thread->exit();
thread->deleteLater();// Delete object 
obj->deleteLater();

Use QObject Methods

1. Write an inheritance QObject Class , Declare the entry function requiring complex and time-consuming logic as slot function .
2. This class is in the old thread new come out , You can't set any parent to it
3. Also declare a QThread, If not new, When destructing, you need to call QThread::wait(), If it's heap allocation , Can pass deleteLater Let the thread destroy automatically .
4. hold obj adopt moveToThread Method to the new thread , here object Already in the thread .
5. Put the thread of finished Signals and object Of deleteLater Slot connection , This signal slot must be connected to , Otherwise, there will be a memory leak .
6. Connect other signals and slots normally , Communicate through signals and slots .
7. After the initialization, it is called QThread::start() To start a thread
8. At the end of the logic , call QThread::quit Exit the thread's event loop

Use QObject To implement multithreading rather than inheritance QThread The method is more flexible , The whole class is in the new thread , Pass data through the signal slot and the main thread

Four 、 Destruction of the thread

connect(&m_thread,&QThread::finished ,&obj,&QObject::deleteLater);

Make a statement QThread, If not new, When destructing, you need to call QThread::wait(),
If it's heap allocation , Can pass deleteLater Let the thread destroy automatically .
（ The heap needs to be destroyed manually by the programmer ）

Insert ：
Decimal display ：
QString test = QString::number(rcvBuf3[5]*256 +rcvBuf3[6]);
QString data = QString::number(rcvBuf3[5]<<8 | rcvBuf3[6]);

summary

Good at summarizing , More further .