多线程具有以下几点优势。
（1）提高应用程序的响应速度。这对于开发图形界面的程序尤为重要，当一个操作耗时很长时，整个系统都会等待这个操作，程序就不能响应键盘、鼠标、菜单等的操作，而使用多线程技术可将耗时长的操作置于一个新的线程，从而避免以上的问题。
（2）使多CPU系统更加有效。当线程数不大于CPU数目时，操作系统可以调度不同的线程运行于不同的CPU上。
（3）改善程序结构。一个既长又复杂的进程可以考虑分为多个线程，成为独立或半独立的运行部分，这样有利于代码的理解和维护。
多线程程序有以下几个特点。
（1）多线程程序的行为无法预期，当多次执行上述程序时，每一次的运行结果都可能不同。
（2）多线程的执行顺序无法保证，它与操作系统的调度策略和线程优先级等因素有关。
（3）多线程的切换可能发生在任何时刻、任何地点。
（4）多线程对代码的敏感度高，因此对代码的细微修改都可能产生意想不到的结果。
Qt线程同步互斥控制的基本方法。线程直接存在着互相制约的关系，具体可分为互斥和同步这两种关系。
多线程控制
实现线程的互斥与同步常使用的类有QMutex、QMutexLocker、QReadWriteLocker、QReadLocker、QWriteLocker、QSemaphore和QWaitCondition。
下面举一个例子来说明问题：
class Key
{
public:
Key() {key=0;}
int creatKey() {++key; return key;}
int value()const {return key;}
private:
int key;
};
虽然类Key产生主键的函数creatKey()只有一条语句执行修改成员变量key的值，但是C++的“++”操作符并不是原子操作，通常编译后，它将被展开成为以下三条机器命令：
- 将变量值载入寄存器。
- 将寄存器中的值加1。
- 将寄存器中的值写回主存。
假设当前的key值为0，如果线程1和线程2同时将0值载入寄存器，执行加1操作并将加1后的值写回主存，则结果是两个线程的执行结果将互相覆盖，实际上仅进行了一次加1操作，此时的key值为1。
为了保证类Key在多线程环境下正确执行，上面的三条指令必须串行执行且不允许中途被打断（原子操作），即线程1在线程2（或线程2在线程1）之前完整执行上述三条机器指令。
实际上，私有变量key是一个临界资源（Critical Resource,CR）。临界资源一次仅允许被一个线程使用，它可以是一块内存、一个数据结构、一个文件或者任何其他具有排他性使用的东西。在程序中，通常竞争使用临界资源。这些互斥执行的代码段称为“临界区（Critical Section,CS）”。临界区（代码段）实施对临界资源的操作，为了阻止问题的产生，一次只能有一个线程进入临界区。通常有相关的机制或方法在程序中加上“进入”或“离开”临界区等操作。如果一个线程已经进入某个临界区，则另一个线程就绝不允许在此刻再进入同一个临界区。
1.互斥量(mutex)
1．QMutex类
QMutex类是对互斥量的处理。它被用来保护一段临界区代码，即每次只允许一个线程访问这段代码。
QMutex类的lock()函数用于锁住互斥量。如果互斥量处于解锁状态，则当前线程就会立即抓住并锁定它，否则当前线程就会被阻塞，直到持有这个互斥量的线程对它解锁。线程调用lock()函数后就会持有这个互斥量，直到调用unlock()操作为止。
QMutex类还提供了一个tryLock()函数。如果互斥量已被锁定，则立即返回。
例如：
class Key
{
public:
Key() {key=0;}
int creatKey() { mutex.lock(); ++key; return key; mutex. unlock();}
int value()const { mutex.lock(); return key; mutex.unlock();}
private:
int key;
QMutex mutex;
};
在上述的代码段中，虽然creatKey（）函数中使用mutex进行了互斥操作，但是unlock()操作却不得不在return之和，从而导致unlock（）操作永远无法执行。同样，value()函数也存在这个问题。
2．QMutexLocker类
Qt提供的QMutexLocker类可以简化互斥量的处理，它在构造函数中接收一个QMutex对象作为参数并将其锁定，在析构函数中解锁这个互斥量，这样就解决了以上问题
例如：
class Key
{
public:
Key() {key=0;}
int creatKey() { QmutexLocker locker(&mutex); ++key; return key; }
int value()const { QmutexLocker locker(&mutex); return key; }
private:
int key;
QMutex mutex;
};
locker（）函数作为局部变量会在函数退出时结束其作用域，从而自动对互斥量mutex解锁。
在实际应用中，一些互斥量锁定和解锁逻辑通常比较复杂，并且容易出错，而使用QMutexLocker类后，通常只需要这一条语句，从而大大简化了编程的复杂程度。
2.信号量（semaphore）
信号量可以理解为对互斥功能的扩展，互斥量只能锁定一次而信号量可以获取多次，它可以用来保护一定数量的同种资源。信号量的典型用例是控制生产者/消费者之间共享的环形缓冲区。
生产者/消费者实例中对同步的需求有两处：
（1）如果生产者过快地生产数据，将会覆盖消费者还没有读取的数据。
（2）如果消费者过快地读取数据，将越过生产者并且读取到一些过期数据。
针对以上问题，可以有两种解决方法：
（1）首先使生产者填满整个缓冲区，然后等待消费者读取整个缓冲区，这是一种比较笨拙的方法。
（2）使生产者和消费者线程同时分别操作缓冲区的不同部分，这是一种比较高效的方法。
例：
#include <QCoreApplication>
#include <QSemaphore>
#include <QThread>
#include <stdio.h>
const int DataSize=1000;
const int BufferSize=80;
int buffer[BufferSize];
/*(a) 首先生产者向buffer中写入数据，直到它到达终点，然后从起点重新开始覆盖已经存在的数据。
* 消费者读取前生者生产的数据，在此处每一个int字长都被看成一个资源，
* 实际应用中常会在更大的单位上进行操作，从而减少使用信号带来的开销。*/
QSemaphore freeBytes(BufferSize);
/*(b) freeBytes 信号量控制可被生产者填充的缓冲区部分，
* 被初始化为BufferSize（80），表示程序一开始有BufferSize个缓冲区单元可被填充。*/
QSemaphore usedBytes(0);
/*(c) useBytes信号量控制可被消费者读取的缓冲区部分，
* 被初始化为0，表示程序一开始时缓冲区中没有数据可供读取*/
class Producer:public QThread
{
public:
Producer();
void run();
};
Producer::Producer()
{
}
void Producer::run()
{
for(int i=0;i<DataSize;i++)
{
freeBytes.acquire();
/*(a) 生产者线程首先获取一个空闲单元，
* 如果此时缓冲区被消费者尚未读取的数据填满，
* 对此函数的调用就会阻塞，直到消费者读取了这些数据为此。
* acquire(n)函数用于获取n个资源，当没有足够的资源时，调用者将被阻塞，直到有足够的可用资源为止。
* 除此之外，QSemaphore类还提供了一个tryAcquire(n)函数，在没有足够的资源时，该函数会立即返回。*/
buffer[i%BufferSize]=(i%BufferSize);
/* (b)一旦生产者获取了某个空闲单元，就使用当前的缓冲区单元序号填写这个缓冲区单元。*/
usedBytes.release();
/*(c) 调用该函数将可用的资源加1，表示消费者此时可以读取这个刚刚填写的单元了。
release(n)函数用于释放n个资源。*/
}
}
class Consumer:public QThread
{
public:
Consumer();
void run();
};
Consumer::Consumer()
{
}
void Consumer::run()
{
for(int i=0;i<DataSize;i++)
{
usedBytes.acquire(); //a 消费者线程首先获取一个可被读取的单元，如果缓冲区中没有包含任何可以读取的数据，
//对此函数的调用就会阻塞，直到生产者生产了一些数据为止。
fprintf(stderr," %d",buffer[i%BufferSize]); //b 一旦消费者获取了这个单元，会将这个单元的内容打印出来。
if(i%16==0&&i!=0)
fprintf(stderr,"\n");
freeBytes.release(); //c 调用该函数使得这个单元变为空闲，以备生产者下次填充。
}
fprintf(stderr,"\n");
}
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
Producer producer;
Consumer consumer;
/* 启动生产者和消费者线程 */
producer.start();
consumer.start();
/* 等待生产者和消费者各自执行完毕后自动退出 */
producer.wait();
consumer.wait();
return a.exec();
}
3.线程等待与唤醒
对生产者和消费者问题的另一个解决方法是使用QWaitCondtion类，允许线程在一定条件下唤醒其他线程。
#include <QCoreApplication>
#include <QWaitCondition>
#include <QMutex>
#include <QThread>
#include <stdio.h>
const int DataSize=50;
const int BufferSize=10;
int buffer[BufferSize];
QWaitCondition bufferEmpty;
QWaitCondition bufferFull;
QMutex mutex; //(a) 使用互斥量保证对线程操作的原子性
int numUsedBytes=0; //(b) 变量numUsedBytes表示存在多少“可用字节”
int rIndex=0; //(c) 本例中启动了两个消费者线程，并且这两个线程读取同一个缓冲区，
//为了不重复读取，设置全局变量rIndex用于指示当前所读取缓冲区位置。
class Producer : public QThread
{
public:
Producer();
void run();
};
Producer::Producer()
{
}
void Producer::run()
{
for(int i=0;i<DataSize;i++) //(a) for循环中的所有语句都需要使用互斥量加以保护，以保证其操作的原子性。
{
mutex.lock();
if(numUsedBytes==BufferSize) //(b) 首先检查缓冲区是否已经填满
bufferEmpty.wait(&mutex); //(c) 如果缓冲区已经填满，则等待“缓冲区有空位”(bufferEmpty变量）条件成立。
/* wait()函数将互斥量解锁并在此等待，其原型如下
* bool QWaiCondition::wait(QMutex *mutex,unsigned long time = ULONG_MAX)
* 第一个参数mutex为一个锁定的互斥量。如果此参数的互斥量在调用时不是锁定的或者出现递归锁定的情况，
* 则wait（）函数将立刻返回。
* 第二个参数time为等待时间。
* 调用wait（）操作的线程使得作为参数的互斥量在调用前首先变为解锁定状态，
* 然后自身被阻塞变为等待状态直到满足一下条件之一：
* 其他线程调用了wakeOne()或者wakeAll()函数，这种情况下将返回“true"值。
* 第二个参数time超时（以毫秒为单位）,该参数默认情况下为ULONG_MAX,表示永不超时，这种情况下将返回“false"值。
* wait()函数返回前会将互斥量参数重新设置为锁定状态，从而保证从锁定状态到等待状态的原子性转换。
*/
buffer[i%BufferSize]=numUsedBytes; //(d) 如果缓冲区未被填满，则向缓冲区中写入一个整数值。
++numUsedBytes; //增加numUsedBytes变量
bufferFull.wakeAll(); //(e)最后唤醒等待“缓冲区有可用数据”(bufferEmpty变量）条件为“真”的线程。
//wakeone()函数在条件满足时随机唤醒一个等待线程，而wakeAll()函数则在条件满足时唤醒所有等待线程。
mutex.unlock();
}
}
class Consumer : public QThread
{
public:
Consumer();
void run();
};
Consumer::Consumer()
{
}
void Consumer::run()
{
forever
{
mutex.lock();
if(numUsedBytes==0)
bufferFull.wait(&mutex); //(a)当缓冲区中无数据时，等待“缓冲区有可用数据”(bufferFull变量）条件成立。
printf("%ul::[%d]=%d\n",currentThreadId(),rIndex,buffer[rIndex]);
//(b) 当缓冲区中有可用数据即条件成立时，打印当前线程号和rIndex变量，以及其指示的当前可读取数据。
//这里为了区分究竟是哪一个消费者线程消耗了缓冲区里的数据，使用了QThread类的currentThreadId（）
//静态函数输出当前线程的ID。这个ID在X11环境下是一个unsigned long类型的值
rIndex=(++rIndex)%BufferSize; //将rIndex变量循环加1
--numUsedBytes; //(c) numUsedBytes变量减一，即可用的数据减一
bufferEmpty.wakeAll(); //(d) 唤醒等待“缓冲区有空位”(bufferEmpty变量）条件的生产者线程。
mutex.unlock();
}
printf("\n");
}
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
Producer producer;
Consumer consumerA;
Consumer consumerB;
producer.start();
consumerA.start();
consumerB.start();
producer.wait();
consumerA.wait();
consumerB.wait();
return a.exec();
}
补充：QWaitCondition 的正确使用方法：https://blog.csdn.net/flyoxs/article/details/54617342
一个Qt线程的例子，用于说明QWaitCondition的作用 https://www.cnblogs.com/lvdongjie/p/7787829.html
waitCondition可以让线程进入休眠而不用退出。
https://bbs.csdn.net/topics/391979239?page=1
https://blog.csdn.net/LG1259156776/article/details/52273929
https://blog.csdn.net/yxy654538632/article/details/49496561
这个例子中含有4个线程，主线程，生产者线程，消费者线程1，消费者线程2；
问题就是：生产者线程中的bufferEmpty.wakeAll()触发，自动unlock()之后 ；互斥量处于需要被抢占的情况，也就是消费者线程1和消费者线程2抢占。那么，会不会出现消费者线程1一直抢占，而2抢占不到的情况呢？
下面是我的程序运行图
