一、基于Qt多线程的实现：

使用qt实现多线程有两种方式：
第一种：继承QThread类：

子类化**QThread**类得到类A
重写run()函数(run函数为虚函数)，一般可以在run函数中给定一个while循环或者for循环
通过实例化得到A的对象a,通过 QThread::start() 函数来启动线程

例如：

a.子类化QThread

class A:public QThread
{Q_OBJECT
public:void run() override{emit sendfromA(4);qDebug()<<"A ID:"<<QThread::currentThreadId()<<endl;}public slots:void get_B(int a){qDebug()<<"A get B signal:"<<a<<endl;sleep(1);qDebug()<<"A::get_B ID:"<<QThread::currentThreadId()<<endl;}
signals:void sendfromA(int a);
};

b.启动线程A：

A *a=new A;
a->start();

c.相关函数：

具体参考QT的官方文档

QThread::start() 开始线程

QThread::quit() 退出线程事件循环

QThread::exit() 退出线程事件循环

QThread::wait() 等待线程退出，线程阻塞

QThread::terminate() 终止线程，所有的事件被停止（该函数较危险，一般使用quit函数）
QThread::started() 和 QThread::finished() QThread 在启动和结束时发出的信号

QThread::sleep(), msleep(), and usleep() second, millisecond, and microsecond：秒、毫秒、微秒

QThread::currentThreadId() and currentThread() 第一个返回线程的ID号，第二个返回QThread的指针

d.线程的退出：

aThread->quit()
//aThread->terminate();
aThread->wait();
delete aThread;

第二种：继承QObject类（相比于前者更加灵活）：

子类化**QObject**类得到类C
设定槽函数，slots函数
通过函数**QObject::moveToThread**到一个QThread实例化的对象mainThread
通过**QObject::connect**函数连接槽函数和信号函数
通过mainThread调用start()函数来启动线程

例如：

官方例程：

class Worker : public QObject{Q_OBJECTpublic slots:void doWork(const QString &parameter) {QString result;/* ... here is the expensive or blocking operation ... */emit resultReady(result);}signals:void resultReady(const QString &result);};class Controller : public QObject{Q_OBJECTQThread workerThread;public:Controller() {Worker *worker = new Worker;worker->moveToThread(&workerThread);connect(&workerThread, &QThread::finished, worker, &QObject::deleteLater);connect(this, &Controller::operate, worker, &Worker::doWork);connect(worker, &Worker::resultReady, this, &Controller::handleResults);workerThread.start();}~Controller() {workerThread.quit();workerThread.wait();}public slots:void handleResults(const QString &);signals:void operate(const QString &);};

a.实例化QObject 对象C

class C:public QObject
{Q_OBJECT
public:C(){}
public slots:void getFromD(){qDebug()<<"C::getFromD ID:"<<QThread::currentThreadId()<<endl;}void init(){qDebug()<<"init"<<endl;}
};

信号与槽连接：
首先是创建D类

class D:public QThread
{Q_OBJECT
public:D(){}void run() override{emit sendfromD();qDebug()<<"D ID:"<<QThread::currentThreadId()<<endl;}
signals:void sendfromD();
};

    QThread *mainThread=new QThread;C *c_Object = new C;D *d_Thread = new D;c_Object->moveToThread(mainThread);QObject::connect(mainThread,&QThread::started,c_Object,&C::init);QObject::connect(mainThread, &QThread::finished, c_Object, &QObject::deleteLater);QObject::connect(d_Thread,&D::sendfromD,c_Object,&C::getFromD);

b.启动线程C：

mainThread->start()

c.相关函数：
QObject::moveToThread() 将Object移动到线程thread中

QObject::deleteLater() 释放QObject对象，一般连接finished() 信号函数和QObject::deleteLater().槽函数

d.线程的退出：

c_Object->deleteLater(); //一定要在QThread线程退出之前
mainThread->quit();
mainThread->wait()

也可以使用QThread::finished信号：(当线程结束的时候可以直接释放QObject)

QObject::connect(mainThread, &QThread::finished, c_Object, &QObject::deleteLater);

二、子线程间的通讯：

1.主线程和次线程之间的通讯
主线程和次线程之间的通讯基本没什么问题，一般通过信号与槽的方式来实现，通过QObject::connect函数来实现信号与槽的连接。一般有两种形式：

第一种形式：

使用SIGNAL和SLOT关键字申明，这种方式可以连接大多数的信号与槽，包括连接私有的槽信号，例如：

MyThread *aThread = new MyThread(0);
MyThread *bThread = new MyThread(1);
QObject::connect(aThread,SIGNAL(send(int)),bThread,SLOT(get(int)),Qt::AutoConnection);

其中注意使用这种方法的时候要保证没有形参，例如下列方法是错误的：

QObject::connect(aThread,SIGNAL(send(int num)),bThread,SLOT(get(int num)),Qt::AutoConnection);

另外，如果利用了Qt默认的类型（float int double）之外，需要使用qRegisterMetaType来进行注册：（如利用OpenCV的Mat传递参数）

qRegisterMetaType<Mat>("Mat");

第二种形式：
通过指针和传递函数地址：

QObject::connect(aThread,&A::send,bThread,&B::get,Qt::AutoConnection);

这种方式方便快捷，但不能连接私有的槽信号private slots:，所以如果定义了私有槽函数，推荐使用第一种方式，但一般来说推荐将槽函数设置为公有public

连接方式：
Qt::DirectConnection 直接连接，当发射信号的时候，直接执行槽函数，接收对象的槽函数和发射信号在同一个线程；
Qt::QueuedConnection 队列连接，发射的信号放到消息队列中（这种方式是安全的）；
Qt::BlockingQueuedConnection 和Qt::QueuedConnection连接类似，会阻塞等待槽函数被执行完毕，错误的使用可能会导致程序出现致命的卡死；
Qt::AutoConnection自动连接，根据signal和slot是否在同一线程自动选择Qt::DirecConnection 和Qt::QueuedConnection

2.子线程之间的通讯
很多人在子线程通讯中会出现发出信号后槽函数无法响应的情况，一般的解决方法有三种：

第一种：

最直接和最简单的方式就是把连接方式改为Qt::DirectConnection，例如线程A和线程B通讯：

class A:public QThread
{Q_OBJECT
public:void run() override{emit sendfromA(4);qDebug()<<"A ID:"<<QThread::currentThreadId()<<endl;}public slots:void get_B(int a){sleep(1);qDebug()<<"A::get_B ID:"<<QThread::currentThreadId()<<endl;}
signals:void sendfromA(int a);
};class B:public QThread
{Q_OBJECT
public:B::B(){}void run() override{emit sendfromB(5);qDebug()<<"B ID:"<<QThread::currentThreadId()<<endl;}public slots:void get_A(int b){//延迟以证明线程是先执行槽函数后跳出再执行run函数后面的语句sleep(1);qDebug()<<"B::get_A ID:"<<QThread::currentThreadId()<<endl;}
signals:void sendfromB(int b);
};

main函数：

A *aThread=new A;
B *bThread=new B;
QObject::connect(aThread,SIGNAL(sendfromA(int)),bThread,SLOT(get_A(int)),Qt::DirectConnection);
QObject::connect(bThread,SIGNAL(sendfromB(int)),aThread,SLOT(get_B(int)),Qt::DirectConnection);qDebug()<<"Main ID:"<<QThread::currentThreadId()<<endl;
aThread->start();
bThread->start();
aThread->wait();
bThread->wait();
delete aThread;
delete bThread;

执行结果：

DirectConnection的方式是实现子线程通讯最简单的，它会让对应的槽函数在发射信号的线程中进行，即线程号相同，我们从中可以看出，发射信号B的线程号为0x203c,槽信号所在线程也为0x203c。这两个线程和主线程号不相同，即相当于是两个子线程。

最后这样就实现了子线程间利用信号与槽的方式通讯。

第二种：

原理和第一种一样。利用moveToThread函数（moveToThread函数不是全部将函数移动到新线程中，而是将槽函数放到新线程中来运行），将aThread的槽函数依附到bThread线程中，同理，将bThread的槽函数依附到aThread线程中，这样，由于选择Qt::AutoConnection，它会判断是否在同一进程，由于moveToThread这样的设置所以这时候就会自动选择为Qt::DirecConnection，所以和第一种方式一样。

 //a作为接受者aThread->moveToThread(bThread);//b作为接收者bThread->moveToThread(aThread);QObject::connect(aThread,SIGNAL(sendfromA(int)),bThread,SLOT(get_A(int)),Qt::AutoConnection);QObject::connect(bThread,SIGNAL(sendfromB(int)),aThread,SLOT(get_B(int)),Qt::AutoConnection);

运行结果：

可以看到槽函数和发射信号的线程为同一个。

第三种：
第三种方式最粗暴，直接使用全局变量或共享内存或者类静态成员变量来进行通信操作，同时使用QMutex类来实现对变量的互斥读写：

QMutex m_lock;
QMutexLocker locker(&m_lock);
...

QMutexLocker会在其局部周期结束时释放控制权，是Qt提供的一种较为方便的实现读写互斥的类。
当然也可以使用：

QMutex m_lock;
m_lock.lock();
...
m_lock.unlock();

实现互斥

所以，通过以上三种方式就可以实现子线程间的通讯了。

Qt：多线程--子线程间通讯相关推荐

关于QT多线程子线程使用信号和
主线程最后必须调用exit()和wait()函数源码地址 http://download.csdn.net/download/u010261063/10185891 #ifndef QSYSENDT ...
【转】JAVA 并发性和多线程 -- 读感 (二线程间通讯，共享内存的机制)
原文地址:https://www.cnblogs.com/edenpans/p/6020113.html 参考文章:http://ifeve.com/java-concurrency-thread-d ...
多线程编程之三——线程间通讯
七.线程间通讯一般而言,应用程序中的一个次要线程总是为主线程执行特定的任务,这样,主线程和次要线程间必定有一个信息传递的渠道,也就是主线程和次要线程间要进行通信.这种线程间的通信不但是难以避免的,而 ...
线程间通讯机制（提高篇）——深入浅出实现原理
前言: 这一篇博文主要是和大家讲解一下线程间通讯机制的内部实现原理,即Handler.Message.MessageQueue.Looper.HandlerThread.AsyncTask类的实现以及 ...
线程间通讯机制（基础篇）——Handler、Runnable、HandlerThread、AsyncTask的使用
前言: android线程通讯机制是android应用开发的基础课程,对于很多初学android的朋友可能还没有完全理解,所以,今天我就做一下知识小结吧. 一.线程安全可能有java基本的朋友都知道 ...
java多线程与线程间通信
转自(http://blog.csdn.net/jerrying0203/article/details/45563947) 本文学习并总结java多线程与线程间通信的原理和方法,内容涉及java线程 ...
Qt多线程-QThreadPool线程池与QRunnable
版权声明:若无来源注明,Techie亮博客文章均为原创. 转载请以链接形式标明本文标题和地址: 本文标题:Qt多线程-QThreadPool线程池与QRunnable 本文地址:http:// ...
java多线程方式轮询,深入理解JAVA多线程之线程间的通信方式
一,介绍本总结我对于JAVA多线程中线程之间的通信方式的理解,主要以代码结合文字的方式来讨论线程间的通信,故摘抄了书中的一些示例代码. 二,线程间的通信方式 ①同步这里讲的同步是指多个线程通过sy ...
RT-Thread学习笔记六——线程间通讯（信号量的使用）
目录 1.概念 1.1 二值型信号量 1.2 计数型信号量 2.信号量的创建(API) 2.1动态信号量创建 2.2动态信号量的删除 2.3静态信号量的创建 2.4静态信号量的删除 3.信号量的获 ...
Linux多线程编程---线程间同步（互斥锁、条件变量、信号量和读写锁）
本篇博文转自http://zhangxiaoya.github.io/2015/05/15/multi-thread-of-c-program-language-on-linux/ Linux下提供了 ...

Qt：多线程--子线程间通讯

一、基于Qt多线程的实现：

二、子线程间的通讯：

Qt：多线程--子线程间通讯相关推荐

最新文章

热门文章