Qt QThread 线程创建，线程同步,线程通信 实例

1. 继承QThread, 实现run()方法， 即可创建线程。



2. 实例1 代码

myThread.h

#ifndef MYTHREAD_H
#define MYTHREAD_H

#include <QThread>

class myThread : public QThread   //myThread 线程类
{
Q_OBJECT

public:
myThread();
void setMessage(const QString &message);
void stop();
protected:
void run();   //复写run()方法，里面是线程 的 主体代码
private:
QString messageStr;
volatile bool stopped;
};

#endif // MYTHREAD_H

myThread.cpp

#include "myThread.h"
#include <QDebug>

myThread::myThread()
{
stopped = false;
}

void myThread::run()  //实现run()方法， 隔1秒输出messageStr
{
while(!stopped)
{
qDebug() << messageStr << endl;
sleep(1);
}
stopped = false;
}

void myThread::stop()
{
stopped = true;
}

void myThread::setMessage(const QString &message)
{
messageStr = message;
}

dialog.h

#ifndef DIALOG_H
#define DIALOG_H

#include <QDialog>
#include <QtGui>
#include "myThread.h"

class Dialog : public QDialog
{
Q_OBJECT

public:
Dialog(QWidget *parent = 0);
~Dialog();

protected:
void closeEvent(QCloseEvent *event);

private slots:
void startOrStopThreadA();
void startOrStopThreadB();

private:
myThread threadA;   //用线程类 实例化 线程对象
myThread threadB;
QPushButton *threadAButton;
QPushButton *threadBButton;
QPushButton *quitButton;
};

#endif // DIALOG_H

dialog.cpp

#include "dialog.h"

Dialog::Dialog(QWidget *parent)
: QDialog(parent)
{
threadA.setMessage("A");
threadB.setMessage("B");

threadAButton = new QPushButton(tr("Start A"));
threadBButton = new QPushButton(tr("Start B"));
quitButton = new QPushButton(tr("Quit"));
quitButton->setDefault(true);
connect(threadAButton, SIGNAL(clicked()), this, SLOT(startOrStopThreadA()));
connect(threadBButton, SIGNAL(clicked()), this, SLOT(startOrStopThreadB()));
connect(quitButton, SIGNAL(clicked()), this, SLOT(close()));

QHBoxLayout *hLayout = new QHBoxLayout;
hLayout->addWidget(threadAButton);
hLayout->addWidget(threadBButton);
hLayout->addWidget(quitButton);
setLayout(hLayout);
}

Dialog::~Dialog()
{
}

void Dialog::startOrStopThreadA()
{
if( threadA.isRunning() )
{
threadA.stop();   //结束线程
threadAButton->setText(tr("Start A"));
}
else
{
threadA.start();   //thread.start()开始线程
threadAButton->setText(tr("Stop A"));
}
}

void Dialog::startOrStopThreadB()
{
if( threadB.isRunning() )
{
threadB.stop();
threadBButton->setText(tr("Start B"));
}
else
{
threadB.start();
threadBButton->setText(tr("Stop B"));
}
}

void Dialog::closeEvent(QCloseEvent *event)  //当用户点击quit按键  或 这退出UI的时候，回调closeEvent函数
{
threadA.stop();
threadB.stop();
threadA.wait();
threadB.wait();
event->accept();
//qDebug("--log--");
}

3. 线程同步

QT线程同步的类有： QMutex, QReadWriteLock, QSemaphore, QWaitcondition.

QMutext互斥锁： 可以锁住一段代码，同一时间只能有一个线程访问。



或者用简化锁QMutexLocked类， 构造函数输入QMutex并将其锁住， 析构函数将其解锁。



QReadWriteLock类， 允许多个线程读共享资源，但是只允许一个线程写共享资源。



QSemaphore 信号量 互斥量， 解决 生产者--消费者 问题





4. 利用信号槽， 主线程和子线程通信，互相发送消息。



子线程向主线程发送 每隔一秒向主线程发送累加数字， 主线程按键信息发送到子线程。。

Thread.h

#ifndef THREAD_H
#define THREAD_H
#include <QThread>

class Thread : public QThread
{
Q_OBJECT
private:
int number;
protected:
void run();
public:
Thread(QObject *parent=0);
~Thread();
signals:
void UpdateSignal(int num);
public slots:
void ResetSlot();
};

#endif // THREAD_H

Thread.cpp

#include "Thread.h"

Thread::Thread(QObject *parent)
{
number = 0;
}

Thread::~Thread()
{
}

void Thread::run()
{
while(1)
{
emit UpdateSignal(number);  //发送更新信号给主线程，附带参数number
number++;
sleep(1);
}
}

void Thread::ResetSlot()
{
number = 0;
emit UpdateSignal(number);  //发送重置number信号
}

widget.h

#ifndef WIDGET_H
#define WIDGET_H

#include <QtGui>
#include "Thread.h"

class Widget : public QWidget
{
Q_OBJECT

public:
Widget(QWidget *parent = 0);
~Widget();

private:
QLabel *label;
QPushButton *startButton;
QPushButton *stopButton;
QPushButton *resetButton;
Thread *myThread;
int number;

signals:
void ResetSignal();

public slots:
void clearSlot();
void startSlot();
void stopSlot();
void updateSlot(int num);

};

#endif // WIDGET_H

widget.cpp

#include "widget.h"

Widget::Widget(QWidget *parent)
: QWidget(parent)
{
startButton = new QPushButton("start");
stopButton = new QPushButton("stop");
resetButton = new QPushButton("reset");
label = new QLabel("empty");

myThread = new Thread();

QVBoxLayout *layout = new QVBoxLayout;
layout->addWidget(label);
layout->addWidget(startButton);
layout->addWidget(stopButton);
layout->addWidget(resetButton);
setLayout(layout);

connect(stopButton, SIGNAL(clicked()), this, SLOT(stopSlot()));
connect(startButton, SIGNAL(clicked()), this, SLOT(startSlot()));
connect(resetButton, SIGNAL(clicked()), this, SLOT(clearSlot()));
connect(myThread, SIGNAL(UpdateSignal(int)), this, SLOT(updateSlot(int)));   //子线程发信号给主线程，更新number
connect(this, SIGNAL(ResetSignal()), myThread, SLOT(ResetSlot()));   //主线程发信号给子线程，重置number信号

resize(200, 200);

}

Widget::~Widget()
{

}

void Widget::startSlot()
{
myThread->start();
}

void Widget::stopSlot()
{
myThread->terminate();
}

void Widget::updateSlot(int num)
{
label->setText(QString::number(num));
}

void Widget::clearSlot()
{
emit ResetSignal();     //主线程发送重置信号 给 子线程
}