启动一个线程的步骤:
(1)  创建一个自己的线程类继承QT中的QThread类   创建线程类WorkThread;
(2)   在自己的WorkThreak类中重新实现run()函数, 该函数是一个死循环, 主要是完成自己需要的功能代码
(3)  使用自己的类WorkThread 实例一个对象,也就是用该类创建一个变量 如: WorkThread *task = new WorkThread (this);
(4)  然后通过start()函数启动这个线程, 如task->start();启动该线程
重载的run()函数就是一个独立运行线程, 要想实现多线程就多次继承QThread类在不同的类中的run()函数中实现不同的功能

当然不止只重载 run() 函数, 可以重载 start() 函数为一个槽函数,使用按钮启动该线程或者连接某个信号启动该线程

实现如下

例子1

(1) 创建类WorkThread继承QThread类; 

WorkThread.h文件:

#ifndef WORKTHREAD_H
#define WORKTHREAD_H
#include <QThread>
 
class WorkThread : public QThread
{
public:
    WorkThread();
private:
    virtual void run();//任务处理线程
public:
    int workCount;//计数
 
signals:
 
public slots:
 
};
#endif // WORKTHREAD_H

WorkThread.cpp文件:

#include "WorkThread.h"
#include <QDebug>
 
 
WorkThread::WorkThread()
{
workCount = 0;
}
 
//(2) run()重新实现
void WorkThread::run()
{
    while(true)
{
workCount++;
        if(workCount>=1000) workCount=0;
        qDebug()<<"WorkThread"<<workCount;
        sleep(1);//线程 睡眠一秒一次
}
}

main.cpp文件:

#include <QCoreApplication> //不创建GUI界面
#include <QDebug>
#include "WorkThread.h"
 
int main(int argc,char** argv)
{
    QCoreApplication app(argc,argv);
 
WorkThread *task = new WorkThread; // (3) 创建一个 WorkThread 对象
    qDebug()<<"线程测试开始:";
task->start();//启动该线程 (4)
    qDebug()<<"线程测试结束:";
 
    return app.exec();
}

工程管理文件 Thread.pro文件:

HEADERS += \
WorkThread.h
 
SOURCES += \
WorkThread.cpp \
main.cpp

工程目录;

程序运行状态:

测试上面的线程使用

task->quit();
task->wait(); 

线程也不会终止, 开启的新线程是死循环啊

例子2

工程文件:

1. 主要想法就是在子线程中的循环设定一个条件,当想停止这个线程时,就改变线程循环的条件

如:  while(isStop==false)  只需要改变  "isStop " 的状态就可以实现线程的循环了

2. 实现一个修改这个标志的函数,方便外部修改

mythread.cpp文件:

#include "mythread.h"
#include <QThread>
#include <QDebug>
myThread::myThread(QObject *parent) : QObject(parent)
{
isStop=false;
}
 
 
void myThread::myTimeout()
{
    while(isStop==false)
{
QThread::sleep(1);
        emit mySignal();
        qDebug()<<"子线程号:"<<QThread::currentThread();
 
        if(true==isStop)
{
            break;
}
}
}
 
//修改线程工作标志的,公共函数
void myThread::setFlag(bool flag)
{
isStop=flag;
}

mythread.h文件

#ifndef MYTHREAD_H
#define MYTHREAD_H
 
#include <QObject>
 
class myThread : public QObject
{
Q_OBJECT
public:
    explicit myThread(QObject *parent = nullptr);
 
    void myTimeout();//线程处理函数, 也就是实际开启的线程
    void setFlag(bool flag=true);//设置线程中标志,用于停止线程
 
signals:
    void mySignal(); //定义一个信号,在该子线程中每秒发射一次该信号
 
private:
    bool isStop;//线程工作标志
 
public slots:
};
 
#endif // MYTHREAD_H

3. 在外部只要调用这个修改标志的公共函数,同时调用 task->quit(); 和 task->wait(); 共同终止一个线程  

widget.cpp文件:

#include "widget.h"
#include "ui_widget.h"
#include <QDebug>
 
 
Widget::Widget(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::Widget)
{
ui->setupUi(this);
 
    //动态分配空间, 不能指定父对象
myT = new myThread;//指定父对象后下面不可以在加入子线程中,下面的子线程相当于其父对象
 
thread = new QThread(this);//创建子线程
 
myT->moveToThread(thread);//把自定义的线程加入到子线程中
 
    connect(myT,&myThread::mySignal,this,&Widget::dealSignal);
 
    qDebug()<<"主线程号:"<<QThread::currentThread();//打印主线程号
 
    connect(this,&Widget::startThread,myT,&myThread::myTimeout);
 
    connect(this,&Widget::destroyed,this,&Widget::deadClose);//右上角"X"关了窗口线程还在运行
 
    //线程处理函数内部,不允许操作图形界面
    //connect()第五个参数的作用,连接方式 默认 队列 直接
    //多线程才有意义
}
 
Widget::~Widget()
{
    delete ui;
}
 
//对话框右上角的 叉号 关闭事件触发的槽函数
void Widget::deadClose()
{
    on_buttonStop_clicked();//停止线程
    delete myT;     //释放线程空间
}
 
//子线程信号触发的主线程中的槽函数
void Widget::dealSignal()
{
    static int i=0;
i++;
ui->lcdNumber->display(i);
}
 
//start按钮触发槽函数
void Widget::on_buttonStart_clicked()
{
    if(thread->isRunning()==true)
{
        return;
}
 
thread->start();//启动线程,但是没有启动线程处理函数
myT->setFlag(false);//修改线程标志后才真启动了线程
 
    //不能直接调用线程处理函数
   // myT->myTimeout();//直接调用,导致,线程处理函数和主线程是在同一线程
 
    //只能通过signal-slot方式调用
    emit startThread();
 
}
 
//stop按钮触发槽函数
void Widget::on_buttonStop_clicked()
{
    if(thread->isRunning()==false)
{
        return ;
}
myT->setFlag(true);
thread->quit();
thread->wait();
}

widget.h文件

#ifndef WIDGET_H
#define WIDGET_H
 
#include <QWidget>
#include "mythread.h"
#include <QThread>
 
namespace Ui {
class Widget;
}
 
class Widget : public QWidget
{
Q_OBJECT
 
public:
    explicit Widget(QWidget *parent = 0);
~Widget();
 
 
private slots:
    void on_buttonStart_clicked();//槽
    void on_buttonStop_clicked(); //槽
 
    void dealSignal();  //子线程信号触发的主线程中的槽函数
    void deadClose();   //对话框右上角的 叉号 关闭事件触发的槽函数
 
signals:
    void startThread();//启动子线程的信号
 
private:
Ui::Widget *ui;
 
myThread *myT;
QThread *thread; //定义一个线程对象指针在构造函数中分配空间
};
 
#endif // WIDGET_H

main.cpp文件

#include "widget.h"
#include <QApplication>
 
int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
Widget w;
w.show();
 
    return a.exec();
}