Qt线程知识总结——QThread

Qt中线程支持的内容

1、与平台无关的线程类，一个线程安全的发送事件的方式以及跨线程的信号-槽的关联。

2、一个QThread代表了一个应用程序中可以独立控制的线程，与进程中的其他线程分享数据，独立执行。

3、QThread从run()函数开始执行。

4、默认的，run()函数通过调用exec()来开启事件循环，并在线程内运行一个Qt事件循环。

 

创建一个线程

1、子类化QThread

2、重新实现run()函数

例子：

//子类化线程类
class child_thread:public QThread
{
    //实现run函数
protect:
    void run();
}

void child_thread::run(){
    /*线程需要实现的功能*/

    //如果需要事件循环
    exec();
}

进程中执行线程

1、调用start()函数开始执行线程

线程执行过程：

1、线程调用start()函数——>start()函数默认调用run()函数——>run()函数执行结束，线程就结束。

2、信号：开始信号==start()、结束信号==finished()、终止信号==terminated()

3、状态查询：isFinished()和isRunning()

4、阻塞操作：wait(),指导线程结束执行

5、获取操作系统中的堆栈：setStackSize()设置自定义的堆栈大小

线程的事件循环

1、调用exec()启动事件循环

2、exit()和quit()函数停止事件循环

线程事件

1、线程拥有一个事件循环，使它能够关联其他线程中的信号到本线程的槽上，这个能力使用了队列关联机制。具体内容为：在使用connect()函数进行信号和槽的关联时，将Qt::ConnectionType类型的参数指定为Qt::QueuedConnect。

2、拥有事件循环可以让线程使用需要事件循环的类，比如QTimer和QTcpSocket类等。但是不能使用任何界面类。

极端环境下终止一个线程的方法

1、使用terminate()函数

2、接着调用QThread::wait()来同步终止

获取线程的静态函数

currentThreadId()和currentThread()返回当前执行的线程的标识符，前者返回该线程的系统特定ID,后者返回一个QThread指针。

自己实现一个线程的思路

1、子类化线程QThread类

2、在子类中实现run()函数，在该函数里面完成线程要做的事情

3、在应用程序中实例化子类线程，在需要的地方调用线程，线程中可以发送信号，在应用程序中使用线程的信号建立器信号-槽连接

4、线程执行过程中的操作，获取、停止等操作

5、线程运行结束的操作

第3点是线程实现功能的逻辑所在，通过信号槽的机制线程可以和当前的应用程序建立联系，线程的内容在用户经常中可以被使用。

使用QObjiect::moveToThread()函数创建线程

//为线程准备的一个类
class Worker:public QObject
{
    Q_OBJECT
public slots:
    void doWork(const QSting &parameter){
        //执行代码
        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);
        /........................../
        /*在构造函数中的一些初始操作*/
        /........................../
        workerThread.start();//线程开始运行，doWork函数在这个线程中执行
        /*moveToThread里面应该实现线程运行的一些初始操作，所以不需要再实现run函数*/
        //线程开始运行后，不会自动结束
    }
    ~Controller(){
        workerThread.quit();
        workerThread.wait();
    }
    public slots:
        void handleResults(const Qstring&);
    signals:
        void operate(const Qstring&);
}

代码可以单独在线程中执行，使用这种方法可以将任意线程中任意对象的任意一个信号关联到本线程的槽上，不同线程之间的信号和槽进行关联是安全的。

同步线程:Qt提供了同步线程的方法

1、相关的类有：QMutex、QReadWrite、QSemaphore、QWaitCondition

2、线程同步的原因：使用线程的思想是多个线程可以尽可能地并发执行。但是总是有一些时刻，一些线程必须停止来等待其他线程。例如：如果两个线程尝试同时访问相同的全局变量，则其结果通常是不确定的。

QMutex提供了一个互斥锁（mutex），在任何时间至多有一个线程可以获得mutex。如果一个线程尝试获得mutex,而此时mutex已经被锁，则这个线程将会睡眠，直到现在获得mutex的线程对mutex进行解锁。互斥锁经常用于对共享数据的访问进行保护。

QReadWrite即读-写锁，与QMutex相似，只不过将对共享数据的访问区分为“读”访问和“写访问”，允许多个线程同时对数据进行“读”访问，同一时间“写”访问只能允许一个线程进行。在可能的情况下，QReadWrite代替QMutex可以提高多线程程序的并发度。

QSemaphore即信号量，是QMutex的一般化，它用来保护一定数量的相同的资源，而互斥锁只能保护一个资源。

QWaitCondition即条件变量，允许一个线程在一些条件满足时唤醒其他的线程。一个或多个线程可以被阻塞来等待一个QWaitCondition,从而设置一个用于wakeOne()或则wakeAll()的条件。使用waitOne()可以唤醒一个随机选取的等待的线程，而使用wakeAll()可以唤醒所有正在等待的线程。

使用QSemaphore保护缓冲区 

理解：信号量在访问数据前要先判断信号量当前的可用数量，如果为0则无法访问，就会进入等待阶段。否则为非0就会访问保护的内容。在访问结束后要释放信号量，被释放的信号量可以是已经用到，也可以是在另外一个线程中访问共享空间的保护信号量，在这里释放信号量说明已经准备好，另外的线程可以访问，结束后恢复上一个线程的信号量。生产者-消费者问题是解决多个线程之间对一块共享内存空间访问的例子。

一块环形缓冲区，生产者在里面生成数据，消费者在里面读取数据，如果里面没有数据就不能读取，所以消费者线程对共享内存的操作需要一个初始值为0的信号量上锁，标识开始时无法读取访问，能够访问的条件是里面开始有数据了，这就需要生产者写入数据，并把该区域信号量-1，标识之后不能写入，并且把限制读操作的信号量+1，读线程就可以读取数据，读出数据后，恢复写操作的信号量，让生产者又可以写入数据。

一开始时，肯定是生成者线程运行，消费者被阻塞。之后二者的运行的顺序不确定，有可能在生产者写入数据时，消费者运行，读取了环形缓冲区里面可以访问的那部分内容，恢复写入信号量。它们写入和读取缓冲区数据是按照顺序进行的，在一个for循环里面，只要信号量非0，就可以访问。

编写多个线程的共享内存访问的程序，逻辑只需要考虑各自线程对内存区域访问的检查和访问后的恢复，检查就是判断内存是否可用，恢复就是复原信号量，至于它们之间访问的顺序，不需要过多考虑，应为顺序是随机的，无法确定，但是只要做好各自的信号量的保护，就可以实现同步线程。

对QSemaphore信号量的使用 

1、声明一个信号量，并初始化能够保护的同种类型数据的个数,如：QSemaphore freeBytes[保护个数]

2、获取信号量freeBytes.acquire(),表示共享内存获取保护，-1

3、释放信号量freeBytes.release()，表示共享内存已用过，+1

可重入与线程安全

Qt文档中，术语”可重入reentrant“和”线程安全thread-safe“用来标记类和函数，从而表明怎样在多线程应用程序中使用它们：一个线程安全的函数可以同时被多个线程调用，即便是它们使用了共享数据，因为该共享数据的所有实例都被序列化了。

一个可重入函数也可以同时被多个线程调用，但是只能是在每个调用使用自己的数据的情况下。

如果每个线程使用一个类的不同的实例，则该类的成员函数可以被多个线程安全地调用，那么这个类被称为可重入的；

如果即使所有线程使用一个类的相同实例，该类的成员函数也可以被多个线程安全地调用，那么该类被称为线程安全的。

注意：只有在文档中标记为线程安全（thread-safe）的Qt类,才可以用于多线程。

QObject的可重入性

大多数的非GUI类，比如QTimer、QTcpSocket、QUdpSocket、QProcess,都是可重入的，可以在多个线程中同时使用这些类。这些类被设计为在单一的线程中进行创建和使用，在一个线程中创建一个对象，然后在另外一个线程中调用这个对象的一个函数是无法保证一定可以工作的。需要注意3个约束条件：

1、QObject的子对象必须在创建它的父对象的线程中创建。这意味着，永远不要将QThread对象（this）作为在该线程中创建的对象的父对象（应为QThread对象本身是在其他线程中创建的）

2、事件驱动对象只能在单一的线程中使用。具体来说，这条规则应用在定时器机制和网络模块中。例如，不可以在对象所在的线程QObject::thread()以外的其他线程中启动一个定时器或者连接一个套接字。

3、必须确保删除QThread对象以前删除在该线程中创建的所有对象，可以通过在run函数中的栈上创建对象来保存这一点。

线程在什么时候使用：将一些非常耗时的操作放在一个单独的工作线程中来进行，等该工作线程完成后将结果返回给主线程，最后由主线程将结果显示到屏幕上。QCoreApplication::exec();必须在主线程中调用。

线程的事件循环

1、每一个线程都有自己的事件循环。初始化线程使用QCoreApplication::exec()来开启它的事件循环（对于独立的对话框界面程序，也可以使用QDialog::exec()）；其它的线程可以使用QThread::exec()来开启一个事件循环，QThread提供了一个exit()函数和一个quit()槽。

2、在一个线程中使用事件循环，使得该线程可以使用那些需要事件循环的非GUI类（如：QTimer、QTcpSocket、QProcess）。也使得该线程可以关联任意一个线程的信号到一个指定线程的槽。

3、如果在一个线程中创建了一个QOject对象，那么这个QObject对象被称为居住在该线程（live in the thread）。发往这个对象的事件由该线程的事件循环进行分派。可以使用QObject::thread()获得该对象所在的线程。

4、可以使用QObject::moveToThread()函数改变对象及其孩子所在的线程（如果该对象有父对象，那么它无法被移动）。

5、在其他线程（不是拥有该QObject对象的线程）中调用delete来删除（或者通过其他方式访问）该QObject对象是不安全的，除非可以确保该对象当前没有在处理事件。可以使用QObject::deleteLater()来代替，这样回发送一个DeferredDelete事件，最终该对象所在线程事件循环将会获取该事件。 

从其他线程中访问QObject子类

1、QObject和它所有的子类都不是线程安全的，这包括了整个事件传递系统。需要时刻记着，正在从其他线程中访问一个对象是，事件循环可能正在向这个对象传递事件。

2、如果调用一个没有在当前线程中的QObject子类的函数，而这个对象有可能会获取事件，那么就必须使用mutex来保护对这个QObject子类的内部数据的所有访问；否者会出现崩溃或者其他意外行为。

3、与其他对象相似，QThread对象居住于（live in）创建该对象的线程。在QThread子类中提供槽一般是不安全的，除非使用mutex来保护成员变量。但是，可以安全地在QThread::run()函数中发射信号，因为信号发射是线程安全的。

跨线程的信号和槽（Qt支持的信号和槽类型）

1、Auto Connection(默认)。如果信号发射和信号接收的对象在同一个线程，那么执行方式与Direct Connection相同。否则，执行方式与Queued Connection相同。

2、Direct Connection。信号发射后，槽立即被调用。槽在信号发送者的线程中执行，而接收并非必须在同一个线程。

3、Queued Connection。控制权返回到接收者线程的事件循环后才调用槽。槽在接收者的线程中执行。

4、Blocking Queued Connection。槽的调用与Queued Connection相同，不同的是当前线程会阻塞直到槽返回。注意：使用这种方式关联在相同线程中的对象时，会引起死锁。

5、Unique Connection。执行方式与Auto Connection相同。只不过关联必须是唯一的。例如：如果在相同的两个对象之间，相同的信号已经关联到了相同的槽上，那么这个关联就不是唯一的，这是connect()函数返回false。