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

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

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

1. 子类化**QThread**类得到类A
2. 重写run()函数(run函数为虚函数)，一般可以在run函数中给定一个while循环或者for循环
3. 通过实例化得到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类（相比于前者更加灵活）：

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

例如：

官方例程：

class Worker : public QObject
  {
      Q_OBJECT

  public 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_OBJECT
      QThread 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();

实现互斥

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

---