Qt深入浅出（十三）多线程与定时器

╰半橙微兮° 2023-07-17 06:17 21阅读 0赞

# 多线程 #

我们之前的程序都是单线程运行，接下来我们开始引入多线程。就相当于以前的一个人在工作，现在多个人一起工作。

Qt中非常有必要使用多线程，这是因为，Qt应用是事件驱动型的，一旦某个事件处理函数处理时间过久，就会造成其它的事件得不到及时处理。

Qt中使用QThread来管理线程，一个QThread对象，就是一个线程。QThread对象也有消息循序exec()函数，用来处理自己这个线程的事件。

实现多线程有两种方式。

## 1 第一种创建线程方式 ##

1.  首先要继承QThread
2.  重写虚函数QThread::run

[ virtual protected] void QThread::run() 
        /* 
        * 基类QThread的run函数只是简单启动exec()消息循环 
        */

例如：

#include <QApplication> 
        #include <QThread> 
        #include <QDebug> 
        class MyThread : public QThread 
        { 
        public: 
            void run () 
          { 
                qDebug() << "QThread begin" << endl; 
                qDebug() << "child thread" << QThread::currentThreadId() << endl; 
                QThread::sleep( 5); 
                qDebug() << "QThread end"   << endl; 
        exec(); 
          } 
        }; 
         
        int main ( int argc , char** argv ) 
        { 
            QApplication app ( argc , argv ); 
         
            MyThread thread; 
            thread. start(); 
            qDebug() << "main thread" << QThread::currentThreadId() << endl; 
        QThread::sleep( 5); 
          qDebug() << "main thread" << QThread::currentThreadId() << endl; 
        thread. quit(); 
        qDebug() << "main thread thread.quit()" << endl; 
        tread. wait(); 
        qDebug() << "main thread thread.wait()" << endl; 
            return app. exec(); 
        }

使用QThread的quit可以退出线程的消息循环，有时候不是马上退出，需要等到cpu的控制权交还给线程的exec()。

一般在子线程退出的时候需要主线程去回收资源，可以调用QThread的wait，等待子线程的退出，然后回收资源.

## 2 第二种创建线程方式 ##

1.  继承 QObject
2.  实例化一个QThread对象
3.  实现槽函数.
4.  QObject子类对象通过moveToThread将自己放到线程QThread对象中.
5.  调用QThread对象的start函数启动线程
6.  必须通过发射信号来让槽函数在线程中执行，发射的信号存放在线程exec()消息队列中。
    
    例如： 
    
    mywork.h

#ifndef MYWORK_H 
        #define MYWORK_H 
        #include <QThread> 
        #include <QDebug> 
        class MyWork : public QObject 
        { 
            Q_OBJECT 
        public slots: 
            void workSlot () 
          { 
                qDebug() << "QThread begin" << endl; 
                qDebug() << "child thread" << QThread::currentThreadId() << endl; 
                QThread::sleep( 5); 
                qDebug() << "QThread end"   << endl; 
          } 
        }; 
        #endif // MYWORK_H

widget.cpp

#include <QApplication> 
        #include <QThread> 
        #include <QDebug> 
        #include "mywork.h" 
         
        int main ( int argc , char** argv ) 
        { 
            qDebug() << "main thread" << QThread::currentThreadId() << endl; 
            QApplication app ( argc , argv ); 
            QThread thread; 
            MyWork work; 
            work. moveToThread( & thread); 
            QObject::connect( & thread, SIGNAL( started()), & work,   SLOT( workSlot())); 
            thread. start(); 
          
            QThread::sleep( 6); 
            qDebug() << "thread is runing" << thread. isRunning() << endl; 
            thread. quit(); //调用quit让线程退出消息循环,否则线程一直在exec循环中 
            thread. wait(); //调用完quit后紧接着要调用wait来回收线程资源 
            qDebug() << "thread is runing" << thread. isRunning() << endl; 
         
            return app. exec(); 
        }

需要特别注意的是：

1.  线槽函数已经执行完进入线程exec()中，可以通过发射信号重新让槽函数在线程中执行。也可以通过quit()退出线程exec()。
2.  QObject派生类对象，将要调用moveToThread，不能指定一个主线程父对象托管内存。
3.  QWidget的对象及派生类对象都只能在GUI主线程运行，不能使用moveToThread移到子线程中，即使没有指定父对象。

*  多线程对象内存释放
    
    既然QObject对象无法托管内存对象，那么到底是先释放线程对象，还是先释放这个QObject对象？
    
     先把QObject在线程循环中释放(使用QObject::deleteLater函数)，然后QThread::quit，然后QThread::wait。

例如：

mywork.h

#ifndef MYWORK_H 
        #define MYWORK_H 
         
        #include <QThread> 
        #include <QDebug> 
        class MyWork : public QObject 
        { 
            Q_OBJECT 
        public: 
         
            ~MyWork() { qDebug() << __FUNCTION__   << endl; } 
        public slots: 
            void workSlot () 
          { 
                while( 1) 
              { 
                    qDebug() << "Work begin" << endl; 
                    QThread::sleep( 5); 
                    qDebug() << "work end"   << endl; 
              } 
          } 
            void otherWorkSlot () 
          { 
                qDebug() << "otherWork begin" << endl; 
                QThread::sleep( 5); 
                qDebug() << "otherWork end"   << endl; 
          } 
         
         
        }; 
         
        #endif // MYWORK_H

widget.h

#ifndef WIDGET_H 
        #define WIDGET_H 
         
        #include <QWidget> 
        #include "mywork.h" 
         
        class Widget : public QWidget 
        { 
            Q_OBJECT 
         
        public: 
            Widget( QWidget * parent = 0); 
            ~Widget(); 
        private: 
            QThread * _thread; 
            MyWork * _myWork; 
        }; 
         
        #endif // WIDGET_H

widget.cpp

#include "widget.h" 
        #include <QPushButton> 
        #include "mywork.h" 
        #include <QThread> 
        #include <QHBoxLayout> 
         
        Widget::Widget( QWidget * parent) 
          : QWidget( parent) 
        { 
            _myWork = new MyWork; 
            _thread = new QThread( this); 
            _myWork -> moveToThread( _thread); 
            _thread -> start(); 
         
            QPushButton * pb0   = new QPushButton( "work", this); 
            QPushButton * pb1   = new QPushButton( "pb", this); 
            QHBoxLayout * hBox = new QHBoxLayout( this); 
            hBox -> addWidget( pb0); 
            hBox -> addWidget( pb1); 
            this -> setLayout( hBox); 
         
            /*发射信号给在另外一个线程的对象的队列中*/ 
            connect( pb0, SIGNAL( clicked()), _myWork, SLOT( workSlot())); 
            connect( pb1, SIGNAL( clicked()), _myWork, SLOT( otherWorkSlot())); 
         
            /*推荐用法释放内存*/ 
            //connect(_thread, SIGNAL(finished()), _myWork, SLOT(deleteLater())); 
         
        } 
         
        Widget::~Widget() 
        { 
            _myWork -> deleteLater(); //一定要在QThread线程退出之前 
            _thread -> quit(); 
            _thread -> wait(); 
        }

## 3 线程的同步 ##

多线程在访问同时一个资源，(例如：多个线程可操作的变量、函数等)，到底谁来使用这个资源是一个问题，就像一大群人去抢同一块蛋糕，可能其中一个人抢到，更有可能蛋糕被抢个稀烂。在多线程中，这个叫作竞争冒险。那么我们需要定一个规则来约束每一个人，比如：每个人排队来领蛋糕，这个在多线程中叫作同步方法。

需要注意的是，同步不是同时，而是有序进行。

### 3.1 互斥锁 ###

Qt中的互斥锁是QMutex，不继承任何Qt基类，使用QMutex来锁共享资源，哪个线程抢到钥匙，哪个线程就有这个资源的使用权，其它线程等待这个线程使用完资源并归还钥匙，然后它们再去抢钥匙。

例如：

QMutex mutex; //这对象一般定义在多个线程能访问的地方 
        mutex. lock(); //多个线程调用这个函数去获取锁，没有获取到的线程，将阻塞等待在这个函数上。 
        mutex. unlock(); //释放锁

*  QMutex::lock函数会让线程等待获取锁，如果不想等待，可以使用一下函数替换:

bool QMutex::tryLock( int timeout = 0) 
        /* 
        *参数 int timeout:等到timeout毫秒，不管有没获取到锁都返回，timeout为0时，直接返回。 
        *返回值 true代表获取到锁，false没有获取到 
        */

*  有时候我们会忘记释放锁，Qt还为我们提供了管理锁的类QMutexLocker

QMutex mutex; 
        void func () 
        { 
            QMutexLocker locker ( _mutex ); //QMutexLocker最好实例化成栈对象，释放之前将QMutex解锁。   
        }

以上例子，一旦func()执行完成locker自动释放，释放之前先解锁。

### 3.2 信号量 ###

互斥锁保护的资源同一时刻只能有一个线程能够获取使用权，有些资源是可以限定多个线程同时访问，那么这个时候可以使用信号量。在Qt中信号量为QSemaphore。

QSemaphore sem ( 2 ) //初始化信号量为2 
        sem . acquire ();   //信号量部位0的时候，调用这个函数会让信号量-1，一旦信号量为零，阻塞等待 
        semaphore. release(); //使信号量+1

## 4 定时器 ##

定时器可以隔一段时间发出信号，通过接收这个信号来处理一些定时任务，需要注意的是，定时器并没有开启一个新线程。Qt中的定时器是QTimer继承自QObject。

*  通过QTimer::start()来启动定时器

void start ( int msec ) 
        /* 
        *定时msec毫秒后，发射timeout()信号 
        */

通过链接信号timeout()来处理一些定时任务，例如：

#include "dialog.h" 
        #include <QTimer> 
        #include <qdebug.h> 
        Dialog::Dialog( QWidget * parent) 
          : QDialog( parent) 
        { 
        QTimer * timer = new QTimer( this); 
        connect( timer, SIGNAL( timeout()), this, SLOT( doSomeThing())); 
            timer -> start( 3000); 
            
        } 
        void Dialog::doSomeThing() 
        { 
            qDebug() <<   __FUNCTION__ << endl; 
        } 
         
        Dialog::~Dialog() 
        { 
         
        }