目录
一、Qt多线程编程
1.介绍
Qt中的多线程的底层原理和注意事项等等内容和Linux中我们描述的多线程本质上是一个东西，不同系统上的多线程库是不一样的，Linux中使用的是pthread第三方库，而Windows又是另一个库，所以在C++编程的时候，考虑到可移植性的问题，通常使用的是C++11的多线程库。
Qt出现的时候，还没有C++11的标准。但是Qt也是一个跨平台的，所以底层就根据不同的操作系统，利用相应的系统调用来实现线程的创建、调度、同步等功能，但又在此基础上提供了统一的、跨平台的 API，让开发者无需关心不同操作系统之间的差异。不使用系统的原生API还有一个原因就是Linux的原生的多线程API，因为C语言的局限性，所以说API的设计使用上来说非常的不方便，一般实际开发中也很少使用原生的API。
简单的说，Qt的多线程库就是对不同操作系统系统调用API的一个封装。
2.多线程的操作
线程的创建
在Qt当中，多线程的处理一般是通过QThread类来实现的。QThread类对象代表一个在应用程序中可以独立控制的一个线程，每一个也就是说QThread对象管理一个线程。Qt中多线程的创建是通过创建一个继承QThread的子类，就相当于创建了一个线程对象，然后通过重写run函数，通过多态的方式实现了指定线程需要执行的代码逻辑。、
但是在C++当中，使用多态机制是不常见的，大多数都是说用回调函数的方式，将函数地址传递给线程会更快捷一些。而使用多态机制的话，会带来一些运行时候的额外开销，因为在运行，需要执行函数的时候，需要查询虚函数表，找到对应的函数对应的地址再去执行。在一些游戏引擎、AI、高性能服务器等场景需要性能做到极致，所以说不能使用上述的多态机制，但是对于Qt这种客户端的开发，其实不需要太极致的性能追求。
QThread的常用API
因为子线程都是继承与QThread的，所以说创建出来的子类，也都是可以调用QThread的相关API的。
| API接口 | 说明 |
| run() | 线程的入口函数 |
| start() | 会调用run()函数，执行线程函数，相当于线程的开关，如果说线程已经运行了，那么什么都不会做。 |
| currentThread() | 返回一个指向管理当前指向线程的QThread的指针对象。也就是返回一个当前线程的对象指针。 |
| isRunning() | 判断线程是否在运行，返回值为bool类型 |
| sleep() / msleep() / usleep() | 线程休眠函数 |
| wait() | 阻塞线程，直到满足以下任何一个条件： 与自身线程关联的一个线程已经执行完毕，或者说还没有启动。两者都会返回true 已经超过了等待时间。函数会返回false（如果设置的是默认值ULONG_MAX，那么永远都不会超时） 该函数与POSIX的pthread_join类似 |
| terminate() | 执行线程的执行，线程可以立即终止，也可以不立刻终止，这取决于OS的调度策略。 |
| finished() | 这是一个线程结束之后发出的信号，可以通过该信号实现线程的清理工作 |
使用案例
创建一个线程去完成一个倒计时程序。
在Qt当中，对于空间内部的实现是有些复杂的，那么如果在线程函数中去修改界面上控件的属性内容，可能就会出现线程安全的问题，所以说Qt一刀切，对于控件属性的任何修改都必须在主线程中执行。所以就不能在子线程中去直接修改LCDNumber控件的数值了，但是我们可以在子线程中实现计时的操作，时间每过一秒钟后，就通过信号槽的机制，通知主线程，负责更新界面的内容。
在创建线程对象的时候，需要将线程对象设置为类变量，否则出了构造函数的局部作用域的话，就会析构销毁了。
//timethread.h文件-----------------------------------
#ifndef TIMETHREAD_H
#define TIMETHREAD_H
#include <QWidget>
#include <QThread>
class TimeThread : public QThread
{
Q_OBJECT
public:
TimeThread();
void run() override;
//自定义信号
signals:
void thread_signal();
};
#endif // TIMETHREAD_H
//timethread.cpp文件-----------------------------------
#include "timethread.h"
TimeThread::TimeThread()
{
}
//重写入口函数
void TimeThread::run()
{
//每隔一秒通知一下主线程
for(int i = 0; i < 10; i++)
{
sleep(1);
//发送信号
emit thread_signal();
}
}
//widget.h文件-------------------------------------
#ifndef WIDGET_H
#define WIDGET_H
#include <QWidget>
#include <timethread.h>
QT_BEGIN_NAMESPACE
namespace Ui { class Widget; }
QT_END_NAMESPACE
class Widget : public QWidget
{
Q_OBJECT
public:
Widget(QWidget *parent = nullptr);
~Widget();
public slots:
void handlersignal();
private:
Ui::Widget *ui;
//创建一个线程对象
TimeThread thread;
};
#endif // WIDGET_H
//widget.cpp文件---------------------------------------
#include "widget.h"
#include "ui_widget.h"
Widget::Widget(QWidget *parent)
: QWidget(parent)
, ui(new Ui::Widget)
{
ui->setupUi(this);
//绑定线程信号
connect(&thread, &TimeThread::thread_signal, this, &Widget::handlersignal);
//启动线程
thread.start();
}
Widget::~Widget()
{
delete ui;
}
void Widget::handlersignal()
{
//获取倒计时的值
int value = ui->lcdNumber->intValue();
if(value <= 0)
{
return;
}
//更新
ui->lcdNumber->display(value - 1);
}3.Qt线程的使用场景
我们日常在提及C++的多线程的时候，通过都是站在服务器的角度上去思考问题，对于服务器来说，最主要的就是性能高效，基于多核CPU的以及双路CPU（一个主板上有两个CPU）的硬件支持，使用多线程可以充分的利用CPU的资源，提高服务器的效率。
而客户端上的侧重点，对于普通用户日常使用来说，并不需要那么高的性能，因为对于人来说0.00001秒和0.1秒或者说1s的区别都不算太大。更重要的是一个用户的体验感。如果采用极致效率的多线程编程的话，会将用户设备的CPU计算资源用完，用户的设备就会很卡了。
更多的使用多线程的场景是在于，采用多线程的方法，执行一些耗时的I/O的操作，避免主线程被卡死而产生不好的体验。例如客户端通常需要和服务器进行网络通信，在下载一些大型文件的时候，需要消耗很长时间，如果我们不采用多线程的话，这种密集的I/O操作相当于是需要等待资源就绪才可以往下运行，那么就会将主线程挂起，不参与CPU的调度执行了，那么用户就无法进行任何操作了。这样的体验感会很差。
在例如早期的大型PC游戏，在启动的时候需要从服务器或者本地文件当中加载大量的资源数据，如果我们在他加载的时候，狂点鼠标或者键盘的话，是没有任何影响的，而且点几下之后，很可能整个窗口就出问题了，Windows会弹出无法影响操作是否要强制关闭的提示窗口，这样用户就会很蒙，也会大大的降低体验感。（其实是游戏在加载，并非游戏出错卡死）
基于上述的两个场景来说，最好的方法就是创建子线程去进行密集的I/O操作，这样就算挂起的话，也是挂起子线程，不会影响主线程的继续运行，不影响继续相应用户的操作。
二、线程安全问题
1.互斥锁
介绍
维护线程安全最有效的方式就是使用锁，将多线程的并发执行转变为串行执行。Qt的锁是对不同系统的底层锁进行了一个封装，封装成了一个QMutex类。对于锁的操作最重要的就是加锁和解锁的操作， QMutex类中提供了lock和unlock成员函数。
Qt中的锁和C++11标准库提供的锁使用方式类似，只需要创建一个锁对象就可以了执行成员函数了，不需要创建锁，并将锁对象管理起来这些操作。
上述虽然使用起来已经很方便了，但是对于锁的释放，实际开发中的工程项目逻辑会非常复杂，很容易就忘记释放锁了，或者在中间过程中直接跳转了，或者抛出异常等等场景，都会使得锁资源忘记释放导致死锁了。所以Qt为我们提供了一个QMutexLocker类，该类其实就是QMutex的辅助类，内部使用的是RAII的方式对互斥锁进行上锁和解锁的操作。简化了互斥锁的上锁和解锁操作，避免忘记解锁导致死锁的问题。这个和C++11提供的shared_lock类似。
使用案例
当我们创建两个线程去执行对一个公共的static变量循环++50000次之后，打印该公共变量发现他的值并非是100000，所以就出现了线程安全问题，在操作++的时候并发访问该变量的值了。所以需要加锁。
//thread.h文件-------------------------------------
#ifndef THREAD_H
#define THREAD_H
#include <QWidget>
#include <QThread>
#include <QMutex>
class Thread : public QThread
{
Q_OBJECT
public:
Thread();
//重写run函数
void run() override;
public:
static int num;
static QMutex mutex;
};
#endif // THREAD_H
//thread.cpp文件-----------------------------------------
#include "thread.h"
int Thread::num = 0;
QMutex Thread::mutex;
Thread::Thread()
{
}
void Thread::run()
{
for(int i = 0; i < 50000; i++)
{
mutex.lock();
num++;
mutex.unlock();
}
}
//widget.cpp文件
#include "widget.h"
#include "ui_widget.h"
#include "thread.h"
#include <QDebug>
Widget::Widget(QWidget *parent)
: QWidget(parent)
, ui(new Ui::Widget)
{
ui->setupUi(this);
//创建两个线程对象
Thread td1;
Thread td2;
//启动线程
td1.start();
td2.start();
//线程等待
td1.wait();
td2.wait();
//打印结果
qDebug() << Thread::num;
}
Widget::~Widget()
{
delete ui;
}
2.读写锁
读写锁也是一个非常经典的锁，适用于读写写者问题，该问题描述的是在一个场景中有一个公共资源的区域，写入线程负责写入数据，那么写入线程之间就需要采用互斥的机制，防止数据的紊乱，为了实现这个操作，提供了写锁，该锁就是一个互斥锁，同一时间只允许一个线程访问临界资源。读取线程则是只会读取内容，所以可以多个读取线程并发访问临界资源。对于读取线程也提供了读取锁，但是该锁并不是互斥锁，更多情况下像是一个用来计数的功能。
Qt中提供了QReadWriteLock类、实现读写锁，同时设计了QReadLock读锁和QWirteLock写锁作为辅助类，配合QReadWriteLock类完成读写线程的同步。该读写锁类中会记录是否有写入线程正在写入，以及是否有读取线程正在读取。
如果说有写入线程正在写入的话，其他写入线程和读取线程都不可以进行访问临界资源，而如果有读取线程正在读取的话，写入线程就会阻塞等待读取线程读取完毕，读取线程没有任何限制。
同时为了防止忘记解锁导致死锁问题，Qt也提供了RAII机制的读写锁类QReadWriteLocker、QReadLocker、QWirteLock。
三、线程的同步
对于线程同步，一句话概括就是让多线程对于共享资源的访问具有一定的顺序性。在多线程的程序中，虽然说可以让计算操作或者I/O操作和主线程分开执行，但是主线程一定是需要计算操作或者I/O操作后的数据，如果说数据没就绪的话，往下执行可能会出现一些意想不到的问题。或者说，两个线程配合执行，所以需要通知对方自己现在的一个状态，也需要设置同步机制，最经典的就是生产消费者模型。
1.条件变量
Qt中的条件变量类是QWaitCondition类，对于条件变量来说主要就是等待条件就绪，以及唤醒操作，该类内部提供了wait、wakeOne以及wakeAll接口。
2.信号量
Qt中的信号量类是QSemaphore类，在构造函数中传递信号量的个数，对于申请信号量的操作是acquire接口，释放信号量是release接口。
