QT (启动一个线程)

启动一个线程的步骤:
(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 

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 


WorkThread::WorkThread()
{
    workCount = 0;
}

//(2) run()重新实现
void WorkThread::run()
{
    while(true)
    {
        workCount++;
        if(workCount>=1000) workCount=0;
        qDebug()<<"WorkThread"<

main.cpp文件:

#include  //不创建GUI界面
#include 
#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 
#include 
myThread::myThread(QObject *parent) : QObject(parent)
{
    isStop=false;
}


void myThread::myTimeout()
{
    while(isStop==false)
    {
        QThread::sleep(1);
        emit mySignal();
        qDebug()<<"子线程号:"<

mythread.h文件

#ifndef MYTHREAD_H
#define MYTHREAD_H

#include 

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 


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()<<"主线程号:"<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 
#include "mythread.h"
#include 

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 

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    Widget w;
    w.show();

    return a.exec();
}