了解 Qt 多线程编程新手必学-c++多线程编程

本文介绍的是了解 Qt 多线程编程，本文并没有过多的去总结多线程的概念，通过了解线程类和一些线程的实现，去真正的弄清楚。首先，我们先来看文章的讲解。

概述

QT通过三种形式提供了对线程的支持。它们分别是，一、平台无关的线程类，二、线程安全的事件投递，三、跨线程的信号-槽连接。这使得开发轻巧的多线程 Qt程序更为容易，并能充分利用多处理器机器的优势。多线程编程也是一个有用的模式，它用于解决执行较长时间的操作而不至于用户界面失去响应。

Qt 线程类

Qt 包含下面一些线程相关的类：

QThread 提供了开始一个新线程的方法

QThreadStorage 提供逐线程数据存储

QMutex 提供相互排斥的锁，或互斥量

QMutexLocker 是一个便利类，它可以自动对QMutex加锁与解锁

QReadWriterLock 提供了一个可以同时读操作的锁

QReadLocker与QWriteLocker 是便利类，它自动对QReadWriteLock加锁与解锁

QSemaphore 提供了一个整型信号量，是互斥量的泛化

QWaitCondition 提供了一种方法，使得线程可以在被另外线程唤醒之前一直休眠。

Qt 高级线程类

QtConcurrent 开启线程事务

QFutureWatcher 观测线程状态

QFuture 线程启动类

QThread创建线程

为创建一个线程，子类化QThread并且重写它的run()函数，例如：

class MyThread : public QThread  
 {  
     Q_OBJECT  
 protected:  
     void run();  
 };  
 void MyThread::run()  
 {  
     ...  
 }

之后调用start，Qt即可创建一个线程，并在线程中执行run()函数中代码，注意UI非线程安全的。

QtConcurrent创建线程

QtConcurrent 创建线程的方法比较多，而且QtConcurrent 本身比较特殊，若系统有空闲线程时，它会调度空闲线程，无空闲线程时将会创建一个线程。（注意：QtConcurrent 创建线程归QthreadPool管理，若超过***线程数，将会进入队列等待），QtConcurrent创建线程的方法多种，以下举例map函数：

QImage scale(const QImage &image)  
 {  
     qDebug() < < "Scaling image in thread" << QThread::currentThread();  
     return image.scaled(QSize(100, 100), Qt::IgnoreAspectRatio, Qt::SmoothTransformation);  
 }  
 
 int main(int argc, char *argv[])  
 {  
     QApplication app(argc, argv);  
 
     const int imageCount = 20;  
 
     // Create a list containing imageCount images.  
     QList images;  
     for (int i = 0; i < imageCount; ++i)  
         images.append(QImage(1600, 1200, QImage::Format_ARGB32_Premultiplied));  
 
     // Use QtConcurrentBlocking::mapped to apply the scale function to all the  
     // images in the list.  
     QList thumbnails = QtConcurrent::blockingMapped(images, scale);  
 
     return 0;  
 }

#p#

Qt 线程同步

QMutex, QReadWriteLock, QSemaphore, QWaitCondition 提供了线程同步的手段。使用线程的主要想法是希望它们可以尽可能并发执行，而一些关键点上线程之间需要停止或等待。例如，假如两个线程试图同时访问同一个全局变量，结果可能不如所愿。

QMutex

QMutex 提供相互排斥的锁，或互斥量。在一个时刻至多一个线程拥有mutex,假如一个线程试图访问已经被锁定的mutex,那么它将休眠，直到拥有mutex的线程对此mutex解锁。Mutexes常用来保护共享数据访问。

QReadWriterLock

QReadWriterLock 与QMutex相似，除了它对 “read”,”write”访问进行区别对待。它使得多个读者可以共时访问数据。使用QReadWriteLock而不是QMutex，可以使得多线程程序更具有并发性。

QReadWriteLock lock;  
 void ReaderThread::run()  
 {  
     lock.lockForRead();  
     read_file();  
     lock.unlock();  
 }  
 void WriterThread::run()  
 {  
     lock.lockForWrite();  
     write_file();  
     lock.unlock();  
 }

QSemaphore

QSemaphore 是QMutex的一般化，它可以保护一定数量的相同资源，与此相对，一个mutex只保护一个资源。下面例子中，使用QSemaphore来控制对环状缓冲的访问，此缓冲区被生产者线程和消费者线程共享。生产者不断向缓冲写入数据直到缓冲末端，再从头开始。消费者从缓冲不断读取数据。信号量比互斥量有更好的并发性，假如我们用互斥量来控制对缓冲的访问，那么生产者，消费者不能同时访问缓冲。然而，我们知道在同一时刻，不同线程访问缓冲的不同部分并没有什么危害。

const int DataSize = 100000;  
 const int BufferSize = 8192;  
 char buffer[BufferSize];  
 QSemaphore freeBytes(BufferSize);  
 QSemaphore usedBytes;  
 class Producer : public QThread  
 {  
 public:  
     void run();  
 };  
 
 void Producer::run()  
 {  
     qsrand(QTime(0,0,0).secsTo(QTime::currentTime()));  
     for (int i = 0; i < DataSize; ++i) {  
         freeBytes.acquire();  
         buffer[i % BufferSize] = "ACGT"[(int)qrand() % 4];  
         usedBytes.release();  
     }  
 }  
 class Consumer : public QThread  
 {  
 public:  
     void run();  
 };  
 void Consumer::run()  
 {  
     for (int i = 0; i < DataSize; ++i) {  
         usedBytes.acquire();  
         fprintf(stderr, "%c", buffer[i % BufferSize]);  
         freeBytes.release();  
     }  
     fprintf(stderr, "\n");  
 }  
 int main(int argc, char *argv[])  
 {  
     QCoreApplication app(argc, argv);  
     Producer producer;  
     Consumer consumer;  
     producer.start();  
     consumer.start();  
     producer.wait();  
     consumer.wait();  
     return 0;  
 }

#p#

QWaitCondition

QWaitCondition 允许线程在某些情况发生时唤醒另外的线程。一个或多个线程可以阻塞等待一QWaitCondition ,用wakeOne()或wakeAll()设置一个条件。wakeOne()随机唤醒一个，wakeAll()唤醒所有。

下面的例子中，生产者首先必须检查缓冲是否已满(numUsedBytes==BufferSize)，如果是，线程停下来等待 bufferNotFull条件。如果不是，在缓冲中生产数据，增加numUsedBytes,激活条件 bufferNotEmpty。使用mutex来保护对numUsedBytes的访问。另外，QWaitCondition::wait() 接收一个mutex作为参数，这个mutex应该被调用线程初始化为锁定状态。在线程进入休眠状态之前，mutex会被解锁。而当线程被唤醒时，mutex会处于锁定状态,而且，从锁定状态到等待状态的转换是原子操作，这阻止了竞争条件的产生。当程序开始运行时，只有生产者可以工作。消费者被阻塞等待bufferNotEmpty条件，一旦生产者在缓冲中放入一个字节，bufferNotEmpty条件被激发，消费者线程于是被唤醒。

const int DataSize = 100000;  
 const int BufferSize = 8192;  
 char buffer[BufferSize];  
 QWaitCondition bufferNotEmpty;  
 QWaitCondition bufferNotFull;  
 QMutex mutex;  
 int numUsedBytes = 0;  
 
 class Producer : public QThread  
 {  
 public:  
     void run();  
 };  
 void Producer::run()  
 {  
     qsrand(QTime(0,0,0).secsTo(QTime::currentTime()));  
 
     for (int i = 0; i < DataSize; ++i) {  
         mutex.lock();  
         if (numUsedBytes == BufferSize)  
             bufferNotFull.wait(&mutex);  
         mutex.unlock();  
 
         buffer[i % BufferSize] = "ACGT"[(int)qrand() % 4];  
 
         mutex.lock();  
         ++numUsedBytes;  
         bufferNotEmpty.wakeAll();  
         mutex.unlock();  
     }  
 }  
 
 class Consumer : public QThread  
 {  
 public:  
     void run();  
 };  
 void Consumer::run()  
 {  
     for (int i = 0; i < DataSize; ++i) {  
         mutex.lock();  
         if (numUsedBytes == 0)  
             bufferNotEmpty.wait(&mutex);  
         mutex.unlock();  
 
         fprintf(stderr, "%c", buffer[i % BufferSize]);  
 
         mutex.lock();  
         --numUsedBytes;  
         bufferNotFull.wakeAll();  
         mutex.unlock();  
     }  
     fprintf(stderr, "\n");  
 }  
 int main(int argc, char *argv[])  
 {  
     QCoreApplication app(argc, argv);  
     Producer producer;  
     Consumer consumer;  
     producer.start();  
     consumer.start();  
     producer.wait();  
     consumer.wait();  
     return 0;  
 }

小结：对于Qt 中多线程编程的介绍就到这了，希望本篇文章对你有所帮助。

了解 Qt 多线程编程 新手必学

了解 Qt 多线程编程新手必学