qt多线程

1.继承QThread,重写run()

main.cpp

#include "mythread.h"
#include <QtGui/QApplication>

int main(int argc, char *argv[])
{
	QApplication a(argc, argv);
	qRegisterMetaType<QVector<int>>("QVector<int>");
	MyThread w;
	w.show();
	return a.exec();
}

mythread.h

#ifndef MYTHREAD_H
#define MYTHREAD_H

#include <QtGui/QWidget>

#include "generate.h"
#include "ui_mythread.h"

class MyThread : public QWidget
{
	Q_OBJECT

public:
	MyThread(QWidget *parent = 0, Qt::WFlags flags = 0);
	~MyThread();
signals:
	void SignalStarting(int num);
public slots:
	void SlotPushButtonStartClicked();
	void SlotRecvGenerate(QVector<int> list);
	void SlotRecvBubbleSort(QVector<int> list);
	void SlotRecvQuickSort(QVector<int> list);
	void SlotDestroy();
private:
	Ui::MyThreadClass ui;
	Generate* gen;
	BubbleSort* bubble;
	QuickSort* quick;
};

#endif // MYTHREAD_H

mythread.cpp

#include "mythread.h"

MyThread::MyThread(QWidget *parent, Qt::WFlags flags)
	: QWidget(parent, flags)
{
	ui.setupUi(this);
	gen = new Generate;
	bubble = new BubbleSort;
	quick = new QuickSort;
	connect(this,SIGNAL(SignalStarting(int)),gen,SLOT(RecvNum(int)));
	connect(ui.pushButton_start,SIGNAL(clicked()),this,SLOT(SlotPushButtonStartClicked()));
	connect(gen,SIGNAL(sendArray(QVector<int>)),bubble,SLOT(recvArray(QVector<int>)));
	connect(gen,SIGNAL(sendArray(QVector<int>)),quick,SLOT(recvArray(QVector<int>)));
	connect(gen,SIGNAL(sendArray(QVector<int>)),this,SLOT(SlotRecvGenerate(QVector<int>)));
	connect(bubble,SIGNAL(finish(QVector<int>)),this,SLOT(SlotRecvBubbleSort(QVector<int>)));
	connect(quick,SIGNAL(finish(QVector<int>)),this,SLOT(SlotRecvQuickSort(QVector<int>)));
	connect(this, SIGNAL(destroy()),this,SLOT(SlotDestroy()));
}

MyThread::~MyThread()
{

}

void MyThread::SlotPushButtonStartClicked()
{
	this->SignalStarting(100000);
	gen->start();
}

void MyThread::SlotRecvGenerate(QVector<int> list)
{
	bubble->start();
	quick->start();
	for(int i=0; i<list.size(); ++i)
	{
		ui.listWidget_randList->addItem(QString::number(list.at(i)));
	}
}

void MyThread::SlotRecvBubbleSort(QVector<int> list)
{
	for(int i=0; i<list.size(); ++i)
	{
		ui.listWidget_bubbleList->addItem(QString::number(list.at(i)));
	}
}

void MyThread::SlotRecvQuickSort(QVector<int> list)
{
	for(int i=0; i<list.size(); ++i)
	{
		ui.listWidget_quickList->addItem(QString::number(list.at(i)));
	}
}

void MyThread::SlotDestroy()
{
	gen->quit();
	gen->wait();
	gen->deleteLater();  // delete t1;

	bubble->quit();
	bubble->wait();
	bubble->deleteLater();

	quick->quit();
	quick->wait();
	quick->deleteLater();
}

generate.h

#ifndef GENERATE_H
#define GENERATE_H

#include <QThread>
#include <QVector>
class Generate : public QThread
{
	Q_OBJECT

public:
	Generate(QObject *parent = 0);
	~Generate();
public slots:
	void RecvNum(int num);
protected:
	void run() override;
signals:
	void sendArray(QVector<int> num);
private:
	int _Num;
};

class BubbleSort : public QThread
{
	Q_OBJECT

public:
	BubbleSort(QObject *parent = 0);
	~BubbleSort();
public slots:
	void recvArray(QVector<int> list);
protected:
	void run() override;
signals:
	void finish(QVector<int> num);
private:
	QVector<int> _list;
};

class QuickSort : public QThread
{
	Q_OBJECT

public:
	QuickSort(QObject *parent = 0);
	~QuickSort();
public slots:
	void recvArray(QVector<int> list);
protected:
	void run() override;
private:
	void quickSort(QVector<int> &s, int l, int r);
signals:
	void finish(QVector<int> num);
private:
	QVector<int> _list;
};

#endif // GENERATE_H

generate.cpp

#include <QElapsedTimer>
#include "generate.h"

Generate::Generate(QObject *parent)
	: QThread(parent)
{

}

Generate::~Generate()
{

}

void Generate::RecvNum(int num)
{
	_Num = num;
}

void Generate::run()
{
	QVector<int> list;
	QElapsedTimer time;
	time.start();
	for(int i=0; i<_Num; ++i)
	{
		list.push_back(qrand() % 100000);
	}
	int milsec = time.elapsed();
	emit sendArray(list);
}

BubbleSort::BubbleSort(QObject *parent /*= 0*/)
{

}

BubbleSort::~BubbleSort()
{

}

void BubbleSort::recvArray(QVector<int> list)
{
	_list = list;
}

void BubbleSort::run()
{
	QElapsedTimer time;
	time.start();
	int temp;
	for(int i=0; i<_list.size(); ++i)
	{
		for(int j=0; j<_list.size()-i-1; ++j)
		{
			if(_list[j] > _list[j+1])
			{
				temp = _list[j];
				_list[j] = _list[j+1];
				_list[j+1] = temp;
			}
		}
	}
	int milsec = time.elapsed();
	emit finish(_list);
}

QuickSort::QuickSort(QObject *parent /*= 0*/)
{

}

QuickSort::~QuickSort()
{

}

void QuickSort::recvArray(QVector<int> list)
{
	_list = list;
}

void QuickSort::run()
{
	QElapsedTimer time;
	time.start();
	quickSort(_list, 0, _list.size()-1);
	int milsec = time.elapsed();
	emit finish(_list);
}

void QuickSort::quickSort(QVector<int> &s, int l, int r)
{
	if (l < r)
	{
		int i = l, j = r;
		// 拿出第一个元素, 保存到x中,第一个位置成为一个坑
		int x = s[l];
		while (i < j)
		{
			// 从右向左找小于x的数
			while (i < j && s[j] >= x)
			{
				//左移, 直到遇到小于等于x的数
				j--;
			}
			if (i < j)
			{
				//将右侧找到的小于x的元素放入左侧坑中, 右侧出现一个坑
				//左侧元素索引后移
				s[i++] = s[j];
			}

			// 从左向右找大于等于x的数
			while (i < j && s[i] < x)
			{
				//右移, 直到遇到大于x的数
				i++;
			}
			if (i < j)
			{
				//将左侧找到的元素放入右侧坑中, 左侧出现一个坑
				//右侧元素索引向前移动
				s[j--] = s[i];
			}
		}
		//此时 i=j,将保存在x中的数填入坑中
		s[i] = x;
		quickSort(s, l, i - 1); // 递归调用
		quickSort(s, i + 1, r);
	}
}