多线程

QThread 线程类是实现多线程的核心类。 Qt 有两种多线程的方法，其中一种是继承 QThread的 run()函数，另外一种是把一个继承于 QObject 的类转移到一个 Thread 里。 Qt4.8 之前都是使用继承 QThread 的 run()这种方法，但是 Qt4.8 之后， Qt 官方建议使用第二种方法。两种方法区别不大，用起来都比较方便，但继承 QObject 的方法更加灵活。 所以 Qt 的帮助文档里给的参考是先给继承 QObject 的类，然后再给继承 QThread 的类。
另外 Qt 提供了 QMutex、 QMutexLocker、 QReadLocker 和 QWriteLocker 等类用于线程之间的同步，详细可以看 Qt 的帮助文档

继承 QThread 的线程

run()方法是继承于 QThread 类的方法，用户需要重写这个方法，一般是把耗时的操作写在这个 run()方法里面 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
#ifndef MAINWINDOW_H
#define MAINWINDOW_H
#include <QMainWindow>
#include <QThread>
#include <QDebug>
#include <QPushButton>

/* 使用下面声明的 WorkerThread 线程类 */
class WorkerThread;
class MainWindow : public QMainWindow
{
	Q_OBJECT

	public:
	MainWindow(QWidget *parent = nullptr);
	~MainWindow();

	private:
	/* 在 MainWindow 类里声明对象 */
	WorkerThread *workerThread;

	/* 声明一个按钮，使用此按钮点击后开启线程 */
	QPushButton *pushButton;

	private slots:
	/* 槽函数，用于接收线程发送的信号 */
	void handleResults(const QString &result);

	/* 点击按钮开启线程 */
	void pushButtonClicked();
};

	/* 新建一个 WorkerThread 类继承于 QThread */
class WorkerThread : public QThread
{
	/* 用到信号槽即需要此宏定义 */
 	Q_OBJECT

	public:
	WorkerThread(QWidget *parent = nullptr) {
	Q_UNUSED(parent);
}

/* 重写 run 方法，继承 QThread 的类，只有 run 方法是在新的线程里 */
void run() override {
	QString result = "线程开启成功";

	/* 这里写上比较耗时的操作 */
	// ...
	// 延时 2s，把延时 2s 当作耗时操作
	sleep(2);
	/* 发送结果准备好的信号 */
	emit resultReady(result);
}
signals:
	/* 声明一个信号，译结果准确好的信号 */
	void resultReady(const QString &s);
};
#endif // MAINWINDOW_H
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
#include "mainwindow.h"
MainWindow::MainWindow(QWidget *parent)
	: QMainWindow(parent)
{
 	/* 设置位置与大小 */
	this->setGeometry(0, 0, 800, 480);
	/* 对象实例化 */
	pushButton = new QPushButton(this);
	workerThread = new WorkerThread(this);
	/* 按钮设置大小与文本 */
	pushButton->resize(100, 40);
	pushButton->setText("开启线程");

	/* 信号槽连接 */
	connect(workerThread, SIGNAL(resultReady(QString)),	this, SLOT(handleResults(QString)));
	connect(pushButton, SIGNAL(clicked()),this, SLOT(pushButtonClicked()));
}

MainWindow::~MainWindow()	//析构函数里面退出函数
{
	/* 进程退出，注意本例 run()方法没写循环，此方法需要有循环才生效 */
	workerThread->quit();

	/* 阻塞等待 2000ms 检查一次进程是否已经退出 */
if (workerThread->wait(2000)) {
		qDebug()<<"线程已经结束！ "<<endl;
	}
}
void MainWindow::handleResults(const QString &result)
{
	/* 打印出线程发送过来的结果 */
	qDebug()<<result<<endl;
}
void MainWindow::pushButtonClicked()
{
	/* 检查线程是否在运行，如果没有则开始运行 */
	if (!workerThread->isRunning())
		workerThread->start();
}

继承 QObject 的线程

耗时的线程放入QThread线程里面。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
ifndef MAINWINDOW_H
#define MAINWINDOW_H
#include <QMainWindow>
#include <QThread>
#include <QDebug>
#include <QPushButton>
#include <QMutexLocker>
#include <QMutex>
/* 工人类 */
class Worker;
class MainWindow : public QMainWindow
{
	Q_OBJECT
public:
	MainWindow(QWidget *parent = nullptr);
	~MainWindow();
private:
	/* 开始线程按钮 */
	QPushButton *pushButton1;
	/* 打断线程按钮 */
	QPushButton *pushButton2;
	/* 全局线程 */
	QThread workerThread;
	/* 工人类 */
	Worker *worker;
private slots:
	/* 按钮 1 点击开启线程 */
	void pushButton1Clicked();
	/* 按钮 2 点击打断线程 */
	void pushButton2Clicked();
	/* 用于接收工人是否在工作的信号 */
	void handleResults(const QString &);
signals:
	/* 工人开始工作（做些耗时的操作 ） */
	void startWork(const QString &);
};
/* Worker 类，这个类声明了 doWork1 函数，将整个 Worker 类移至线程 workerThread*/
class Worker : public QObject
{
	Q_OBJECT
private:
	/* 互斥锁 */
	QMutex lock;
	/* 标志位 */
	bool isCanRun;
	public slots:
	/* 耗时的工作都放在槽函数下，工人可以有多份不同的工作，但是每次只能去做一份 */
	void doWork1(const QString &parameter) {
	/* 标志位为真 */
		isCanRun = true;
	/* 死循环 */
		while (1) {
		/* 此{}作用是 QMutexLocker 与 lock 的作用范围，获取锁后，运行完成后即解锁 */
		{
			QMutexLocker locker(&lock);
			/* 如果标志位不为真 */
			if (!isCanRun) {
			/* 跳出循环 */
				break;
			}
		}
	/* 使用 QThread 里的延时函数，当作一个普通延时 */
		QThread::sleep(2);
		emit resultReady(parameter + "doWork1 函数");
	}
	/* doWork1 运行完成，发送信号 */
	emit resultReady("打断 doWork1 函数");
}
// void doWork2();...
public:
/* 打断线程（注意此方法不能放在槽函数下） */
void stopWork() {
	qDebug()<<"打断线程"<<endl;

/* 获取锁后，运行完成后即解锁 */
	QMutexLocker locker(&lock);
	isCanRun = false;
}
signals:
/* 工人工作函数状态的信号 */
	void resultReady(const QString &result);
};
#endif // MAINWINDOW_H
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
#include "mainwindow.h"
MainWindow::MainWindow(QWidget *parent)
	: QMainWindow(parent)
{
	/* 设置显示位置与大小 */
	this->setGeometry(0, 0, 800, 480);
	pushButton1 = new QPushButton(this);
	pushButton2 = new QPushButton(this);
	/* 设置按钮的位置大小 */
	pushButton1->setGeometry(300, 200, 80, 40);
	pushButton2->setGeometry(400, 200, 80, 40);
	* 设置两个按钮的文本 */
	pushButton1->setText("开启线程");
	pushButton2->setText("打断线程");
	/* 工人类实例化 */
	worker = new Worker;
	/* 将 worker 类移至线程 workerThread */
	worker->moveToThread(&workerThread);
	/* 信号槽连接 */
	/* 线程完成销毁对象 */
	connect(&workerThread, SIGNAL(finished()), worker, SLOT(deleteLater()));
	connect(&workerThread, SIGNAL(finished()), &workerThread, SLOT(deleteLater()));
	/* 发送开始工作的信号，开始工作 */
	connect(this, SIGNAL(startWork(QString)), worker, SLOT(doWork1(QString)));
	/* 接收到 worker 发送过来的信号 */
	connect(worker, SIGNAL(resultReady(QString)),this, SLOT(handleResults(QString)));
	/* 点击按钮开始线程 */
	connect(pushButton1, SIGNAL(clicked()), this, SLOT(pushButton1Clicked()));
	/* 点击按钮打断线程 */
	connect(pushButton2, SIGNAL(clicked()), this, SLOT(pushButton2Clicked()));
}
MainWindow::~MainWindow()
{
	/* 打断线程再退出 */
	worker->stopWork();
	workerThread.quit();
	/* 阻塞线程 2000ms，判断线程是否结束 */
	if (workerThread.wait(2000)) {
		qDebug()<<"线程结束"<<endl;
	}
}
void MainWindow::pushButton1Clicked()
{
	/* 字符串常量 */
	const QString str = "正在运行";
	/* 判断线程是否在运行 */
	if(!workerThread.isRunning()) {
	/* 开启线程 */
		workerThread.start();
}
/* 发送正在运行的信号，线程收到信号后执行后返回线程耗时函数 + 此字符串 */
	emit this->startWork(str);
}
void MainWindow::pushButton2Clicked()
{
/* 如果线程在运行 */
	if(workerThread.isRunning()) {
/* 停止耗时工作，跳出耗时工作的循环 */
	worker->stopWork();
	}
}
void MainWindow::handleResults(const QString & results)
{
	/* 打印线程的状态 */
	qDebug()<<"线程的状态： "<<results<<endl;
}