Qt 线程

Qt中线程的解释：

QThread(线程)，代表一个在应用程序中可以独立控制的线程，可以和进程中的其他线程分享数据。QThread 对象管理程序中的一个控制线程。QThreads 在 run（）中开始执行。默认情况下，run（）通过调用 exec（）来启动事件循环，并在线程内运行 Qt 事件循环

线程的使用条件：常用于比较耗时的任务，使用线程执行的话，主界面才能正常运行。

创建线程的方法：

继承QThread 重写run函数
继承QObject 通过moveToThread（thread），交给thread执行
继承QRunnable 重写run函数，但必须使用线程池（QThreadPool）运行

继承QThread的特点：

可以通过信号槽与外界进行通信
线程中的对象必须在run函数中创建
每次新建一个线程都需要继承QThread，实现一个新类，使用不太方便。
要自己进行资源管理，线程释放和删除。并且频繁的创建和释放会带来比较大的内存开销。

（适用场景：那些常驻内存的任务）

继承QObject 通过moveToThread（thread）的特点：

使用比较简单方便
但只能执行槽函数中的内容，需要通过信号与槽的方式连接
创建对象时不能指定父类，如果指定父类，那么将无法调用到线程中

注意：线程种无法使用任何界面部件类

第一种创建方式：

class Thread : public QThread //继承QThread
{
    Q_OBJECT
public:
    explicit Thread(QObject *parent = nullptr);
protected:
    void run() override;//重写run函数
};

void Thread::run()
{
  //执行比较耗时的任务
}


//在主类中调用

Thread  thread1;

thread.start();//开起线程，就会执行run函数

第二种创建方式：

class Worker : public QObject //继承自QObject
{
    Q_OBJECT

public slots:
    void doWork(const QString &parameter) {
        QString result;
        /* ... here is the expensive or blocking operation ... */
        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);//移动到线程种执行
        //当线程执行完成后，销毁work对象
        connect(&workerThread, &QThread::finished, worker, &QObject::deleteLater);
        connect(this, &Controller::operate, worker, &Worker::doWork);
        connect(worker, &Worker::resultReady, this, &Controller::handleResults);
        workerThread.start();//开启线程
    }
    ~Controller() {
        workerThread.quit();//关闭线程
        workerThread.wait();//堵塞线程
    }
public slots:
    void handleResults(const QString &);
signals:
    void operate(const QString &);

QThread 常用的函数：

exec（）	进入事件循环并等待 exit（）被调用，返回传递给exit（）的值。如果通过 quit（）调用 exit（），则返回的值为 0。此函数旨在从 run（）中调用。必须调用此函数才能启动事件处理
exit（）	告知线程的事件循环以返回代码退出
currentThread()	返回指向管理当前正在执行的线程的 QThread 的指针。
idealThreadCount()	返回可在系统上运行的理想线程数,如果无法检测到处理器内核数，则此函数返回 1。
isDone()	如果线程完成返回true 否则返回 false
isRunning（）	如果线程正在运行返回true 否则返回 false
msleep（）	强制当前线程休眠毫秒
sleep（）	强制当前线程休眠几秒钟，此功能不保证准确性。在重负载条件下，应用程序可能会休眠超过秒。
usleep()	强制当前线程休眠 usecs微秒，此功能不保证准确性。在重负载条件下，应用程序可能比 usecs 休眠时间更长
requestInterruption()	请求中断线程。该请求是建议性的，由线程上运行的代码决定是否以及如何对此类请求进行操作。此函数不会停止线程上运行的任何事件循环，也不会以任何方式终止它。
run()	线程的起点,调用 start(）后，新创建的线程调用此函数,您可以重新实现此函数以促进高级线程管理
quit()	告知线程的事件循环退出并返回代码 0（成功）。等效于调用 QThread::exit（0）
wait()	阻塞线程,直到如果线程已完成，此函数将返回 true。如果线程尚未启动，它也返回 true。或到了最后期限。如果达到截止时间，此函数将返回 false
start()	通过调用 run（）开始执行线程。操作系统将根据优先级参数调度线程。如果线程已在运行，则此函数不执行任何操作
terminate()	终止线程的执行。线程可能会也可能不会立即终止，具体取决于操作系统的调度策略。在 terminate（）之后使用 QThread：：wait（）可以肯定。

signals

finished()	此信号在完成执行之前从关联的线程发出
started()	在调用run（）函数之前，当关联线程开始执行时，此信号从关联线程发出

例子：

主界面有，开启，暂停，关闭按钮，在一个QLabel显示线程中的数据

创建一个myThread类继承自QThread

class myThread : public QThread
{
    Q_OBJECT
public:
    explicit myThread(QObject *parent = nullptr);

    void stop_thread()//暂停
    {
        thread_run=false;//设置为不可执行
    }

    void run()//重写run函数    (函数直接在这里实现，比较好查看)
    {
        while(thread_run)//如果可以执行
        {
            a+=10;
            emit show_number(a);//触发信号
            sleep(1);//休眠5秒
        }
        thread_run=true;

    }
protected:
    volatile bool thread_run=true;//判断是否可以运行
    int a=0;

signals:
    void show_number(int i);//发送信号给主窗口，显示数据

};

主类中的使用：

.cpp文件中：

Widget::Widget(QWidget *parent)
    : QWidget(parent)
    , ui(new Ui::Widget)
{
    ui->setupUi(this);
    myThread *thread=new myThread;
    qDebug()<<"本机线程数"<<thread->idealThreadCount();//查看自己的线程数
    connect(ui->pushButton,&QPushButton::clicked,[=]()//开启线程
    {
        thread->start();
        qDebug()<<"线程已开启";
        qDebug()<<"线程id"<<thread->currentThreadId();
    });
    connect(ui->pushButton_2,&QPushButton::clicked,[=]()//暂停线程
    {
        thread->stop_thread();//暂停
        qDebug()<<"线程已暂停";
    });
    connect(ui->pushButton_3,&QPushButton::clicked,[=]()//结束线程
    {
        ui->lcdNumber->display(0);
        thread->stop_thread();//暂停
        thread->quit();
        thread->wait();
        thread->deleteLater();//销毁
        ui->pushButton->setEnabled(false);//开启不可点击
    });
    connect(thread,SIGNAL(show_number(int)),this,SLOT(show_data(int)));

}
void Widget::show_data(int s)
{
    ui->lcdNumber->display(s);
}

Widget::~Widget()
{
    delete ui;
}

重入和线程安全：

在整个文档中，重入和线程安全用于标记类和函数，从而表明怎样在多线程应用中使用它们。

线程安全函数可以从多个线程同时调用，即使调用使用共享数据也是如此，因为对共享数据的所有引用都是序列化的。
也可以从多个线程同时调用重入函数，但前提是每个调用都使用自己的数据

以上可以得出结论：线程安全函数始终是可重入的，但可重入函数并不总是线程安全的。

通过扩展，如果可以从多个线程安全地调用一个类的成员函数，只要每个线程使用该类的不同实例，则该类就被称为可重入类。如果可以从多个线程安全地调用该类的成员函数，则该类是线程安全的，即使所有线程都使用该类的同一实例也是如此。

重入：

c++类通常是可重入的，因为它们只能访问自己的成员数据。任何线程都可以在可重入类的实例上调用成员函数，只要没有其他线程可以同时调用该类的同一实例上的成员函数。

例如：

class Counter
{
public:
    Counter() { n = 0; }

    void increment() { ++n; }
    void decrement() { --n; }
    int value() const { return n; }

private:
    int n;
};

上面的类是可重入的，但这并不是线程安全的，当有多个线程同时修改类的一个成员变量，可能会

会产生多种结果。因为++和--的操作并不是总是原子的（原子操作是指一个操作不会被其他线程中断）。它们会分为3个机械指令：

在寄存器中加载变量的值
递增或递减寄存器的值
将寄存器的值存储回主存储器

当有多个线程同时加载变量的旧值，然后递增它们的寄存器，然后将其存储回去，最终它们会相互覆盖，变量只会递增一次。

线程安全：

显然，当有多个线程访问时，访问必须序列化，当有一个线程访问时，其他线程必须等待。

例如：使用QMutex保护数据的访问。

class Counter
{
public:
    Counter() { n = 0; }

    void increment() { QMutexLocker locker(&mutex); ++n; }
    void decrement() { QMutexLocker locker(&mutex); --n; }
    int value() const { QMutexLocker locker(&mutex); return n; }

private:
    mutable QMutex mutex;
    int n;
};

在构造函数中自动锁定互斥锁，在函数结束时调用析构函数时解锁互斥锁，锁定互斥锁可确保序列化来自不同线程的访问。数据成员mutex是用限定符mutable声明的，因为我们需要锁定和解锁value中的互斥锁，因为这是一个 const 函数。

同步线程：

线程的目的是允许并行运行，但有时线程必须停止等待其他线程。例如，如果两个线程尝试访问同一个变量，这样的话结果是未定义的。强制线程相互等待的原则成为互斥，是一种保护共享资源的常用技术。

同步线程类：

QMutex 互斥锁
QReadWriteLock 读-写锁
QSemaphore 信号量
QWaitCondition 条件变量

QMutex（互斥锁）

提供一个互斥锁，在任何事件至多有一个线程可以获得mutex。如果一个线程尝试获得mutex，而mutex已经锁住，那么这个线程将会睡眠

QReadWriteLock （读-写锁）

读-写锁，于QMutex相似，但它对共享数据进行访问的区分，分为“读”，“写”访问，允许多个线程同时对数据进行“读”访问，QReadWiteLock的并行度大于QMutex

QSemaphore 信号量

QSemaphore是QMutex的概括，可保护一定数量的相同资源。相比之下，QMutex 只保护一种资源。信号量示例显示了信号量的典型应用：同步对生产者和使用者之间循环缓冲区的访问

QWaitCondition 条件变量

QWaitCondition，允许一个线程在一些条件满足时唤醒其他线程，不是通过强制执行互斥而是通过提供条件变量来同步线程。一个或多个线程可以被堵塞来等待一个QWaitCondition，使用wakeOne()可以唤醒一个随机选取的等待的线程，使用wakeAll（）可以唤醒所有正在等待的线程

QMutex

QMutex通常和QMutexLocker一起使用，才可以确保这可以轻松确保锁定和解锁的执行一致。

常用函数：

isRecursive（）	判断互斥锁是否为递归（Qt 5.7引入）
lock（）	锁定互斥锁，如果另一个线程锁定了互斥锁，则此调用将阻塞，直到该线程解锁它
tryLock（int ）	尝试锁定互斥锁，如果已获得锁，则函数返回true 否则返回 false，可以设置等待时间。如果获得锁则必须使用unlock（）解锁互斥锁，这样才能在另一个线程才能成功锁定它。
try_lock()	尝试锁定互斥锁，如果已获得锁，则函数返回true 否则返回 false,提供此功能是为了与标准库概念兼容,等价于tryLock（）（Qt 5.8 引入）
try_lock_for()	尝试锁定互斥锁，如果已获得锁，则函数返回true 否则返回 false, 如果获得锁，必须使用unlock（）解锁互斥锁如果为递归互斥锁，允许在同一线程的容易个互斥锁上多次调用该函数如果此互斥锁是非递归互斥锁，则在尝试递归锁定互斥锁时，此函数将始终返回 false。（Qt 5.8 引入）
try_lock_until（）	尝试锁定互斥锁，如果已获得锁，则函数返回true 否则返回 false, 如果获得锁，必须使用unlock（）解锁互斥锁如果为递归互斥锁，允许在同一线程的容易个互斥锁上多次调用该函数如果此互斥锁是非递归互斥锁，则在尝试递归锁定互斥锁时，此函数将始终返回 false。（Qt 5.8 引入）
unlock（）	解锁互斥锁。

QMutex：：QMutex（QMutex::RecursionMode mode)

创建一个互斥锁时可以设置模式

QMutex::Recursive	在这种模式下，线程可以多次锁定同一个互斥锁,并且在进行相应数量的 unlock（）调用之前，互斥锁不会被解锁
QMutex::NonRecursive	在此模式下，线程只能锁定一次互斥锁

互斥锁使用场景：当一个变量同时被多个线程访问

int number=10;

void text()
{
    number*=2;
    number+=5;
}
void text1()
{
    number+=10;
    number*3;
}

正常调用 text（）和text1()的话

text()  number=2*10=20+5=25
text1() number=25+10=30*3=90

同时调用的话：可能会发生以下情况

线程1调用text()
number=10*2=20;
线程2调用text1()，现在text()的调用暂停
number=20+10=30
number=30*3=90;
继续完成线程text()
number=90+5=95

为了防止以上情况，可以上个互斥锁，使得调用完某个函数才能调用其他函数。

QMutex mutex;//互斥锁

int number=10；

void text()
{
     mutex.lock();//上锁
     number*=2;
     number+=5;
     mutex.unlock();//解锁  
}

void text1()
{
     mutex.lock();//上锁
     number+=10;
     number*=3;
     mutex.unlock();//解锁  
}

QMutexLocker类

QMutexLocker类是一个方便点的类，可以简化锁定和解锁的互斥锁。

使用方法：QMutexLocker应该在需要锁定QMutex的函数中创建，创建一个QMutexLock时，互斥锁被锁定。（更加方便）

函数：

mutex(()	返回正在运行的互斥锁
relock（）	重新锁定未锁定的互斥锁锁。
unlock（）	解锁此互斥锁

使用QMutex的情况：需要在分支中解锁互斥锁

int complexFunction(int flag)
{
    mutex.lock();

    int retVal = 0;

    switch (flag) {
    case 0:
    case 1:
        retVal = moreComplexFunction(flag);
        break;
    case 2:
        {
            int status = anotherFunction();
            if (status < 0) {
                mutex.unlock();
                return -2;
            }
            retVal = status + flag;
        }
        break;
    default:
        if (flag > 10) {
            mutex.unlock();
            return -1;
        }
        break;
    }

    mutex.unlock();
    return retVal;
}

QMutexLocker的使用

int complexFunction(int flag)
{
    QMutexLocker locker(&mutex);//创建一个QmutexLocker对象

    int retVal = 0;

    switch (flag) {
    case 0:
    case 1:
        return moreComplexFunction(flag);
    case 2:
        {
            int status = anotherFunction();
            if (status < 0)
                return -2;
            retVal = status + flag;
        }
        break;
    default:
        if (flag > 10)
            return -1;
        break;
    }

    return retVal;
}

当函数执行完后，QMutexLocker对象销毁时，互斥锁会解锁，就不用每个分支去解锁。

使用QMutexLocker::mutex()可以获取当前正在运行的互斥锁。

QReadWriteLock(读-写锁)

读写锁是一种同步工具，用于保护可以访问以进行读取和写入的资源。如果要允许多个线程同时具有只读访问权限，则这种类型的锁定很有用，但是一旦一个线程想要写入资源，就必须阻止所有其他线程，直到写入完成。

函数：

lockForRead（）	锁定读取，如果另一个线程已锁定写入，此函数将阻止当前线程。如果线程已锁定写入，则无法锁定读取。
lockForWrite（）	锁定写入如果另一个线程（包括当前线程）已锁定以进行读取或写入，则此函数将阻止当前线程
tryLockForRead（）	尝试锁定以进行读取，如果线程已锁定写入，则无法锁定读取
tryLockForWrite（）	尝试锁定以进行写入，如果线程已锁定以进行读取，则无法锁定写入
unlock（）	解锁

QReadWriteLock通常使用于经常读取数据，可以多个线程同时读取数据。

QReadWriteLock lock;

void ReaderThread::run()
{
    ...
    lock.lockForRead();
    read_file();
    lock.unlock();
    ...
}

void WriterThread::run()
{
    ...
    lock.lockForWrite();
    write_file();
    lock.unlock();
    ...
}

QSemaphore（信号量）

信号量是互斥锁的概括。虽然互斥锁只能锁定一次，但可以多次获取信号量。信号量通常用于保护一定数量的相同资源

函数：

acquire（int n）	尝试获取n个由信号量保护的资源，当资源不够时将堵塞直到资源足够。
release（int n）	释放由信号量保护的 n 个资源，此函数也可用于“创建”资源。
available（）	返回信号灯当前可用的资源数。这个数字永远不能是负数。
tryAcquire（int n）	尝试获取由信号量保护的资源，成功返回true，否则返回false
tryAcquire（int n,int timeout ）	尝试获取由信号量保护的资源，成功返回true，否则返回false，调用最多等待timeout秒

QSemaphore的创建

QSemaphore::QSemaphore(int n=0)

创建新的信号量，并将其保护的资源数初始化为 n（默认为 0）。

    QSemaphore sem(5);
    sem.acquire(3);
    qDebug()<<"资源还有"<<sem.available()<<"个";
    sem.acquire(2);
    qDebug()<<"资源还有"<<sem.available()<<"个";
    sem.release(5);
    qDebug()<<"资源还有"<<sem.available()<<"个";

当释放的资源多余需要释放的资源时，多余的会进行创建

    QSemaphore sem(5);
    sem.acquire(3);
    qDebug()<<"资源还有"<<sem.available()<<"个";
    sem.release(5);
    qDebug()<<"资源还有"<<sem.available()<<"个";
    sem.release(10);
    qDebug()<<"资源还有"<<sem.available()<<"个";

当资源少于需要获取的资源时，不会获取成功。

    QSemaphore sem(5);
    if(sem.tryAcquire(7)){
        qDebug()<<"获取成功";
    }
    else
    {
        qDebug()<<"获取失败";
    }

QSemaphore信号量的生产者消费者问题。

全局变量：

const int DataSize=1000;//生产者的数据量
const int BufferSize=800;//缓冲区大小
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[%BufferSize]="ACGT"[(int)qrand %4];
        qDebug()<<QString("Producer:%1").arg(buffer[i%buffersize]);
        usedBytes.release();

}

消费者类：

class Consumer ：public QThread
{
public:
   void run();
}

void Producer::run()
{
    for(int i=0;i<DataSize;++i){
        userBytes.acquire();
        qDebug()<<QString("Producer:%1").arg(buffer[i%buffersize]);
        freeBytes.release();
    }

}

main（）

int main(int argc, char *argv[])
{
    QCoreApplication app(argc, argv);
    Producer producer;//生产者
    Consumer consumer;//消费者
    producer.start();//开启线程
    consumer.start();//开启线程
    //两个线程调用wait()，阻塞线程，确保两个线程在退出前都有时间能完成main()
    producer.wait();
    consumer.wait();
    return 0;
}

QWaitCondition

允许一个线程在一些条件满足时唤醒其他线程，不是通过强制执行互斥而是通过提供条件变量来同步线程。一个或多个线程可以被堵塞来等待一个QWaitCondition，使用wakeOne()可以唤醒一个随机选取的等待的线程，使用wakeAll（）可以唤醒所有正在等待的线程

函数：

wait(QMutex*，time)	释放锁定的互斥锁并等待等待条件
wakeOne()	唤醒一个等待等待条件的线程。唤醒的线程取决于操作系统的调度策略，无法控制或预测。如果要唤醒特定线程，解决方案通常是使用不同的等待条件，并让不同的线程等待不同的条件
wakeAll()	唤醒等待等待条件的所有线程。线程的唤醒顺序取决于操作系统的调度策略，无法控制或预测。
notify_one()	提供此函数是为了与 STL 兼容。它等效于 wakeOne（）Qt 5.8中引入
notify_all()	提供此函数是为了与 STL 兼容。它等效于 wakeAll（）Qt 5.8中引入

QWaitCondition的示例：

使用QWaitCondition的QMutex解决生产者-消费者问题

设置全局变量：

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:
    Producer(QObject *parent = NULL) : QThread(parent)
    {
    }

    void run() override
    {
        for (int i = 0; i < DataSize; ++i) {
            mutex.lock();//上锁
            if (numUsedBytes == BufferSize)//检查缓冲区是否已满
                bufferNotFull.wait(&mutex);//已满的话等待条件满足
            mutex.unlock();//解锁
            //存放数据(随机数)
            buffer[i % BufferSize] = "ACGT"[QRandomGenerator::global()->bounded(4)];
            
            mutex.lock();//上锁
            ++numUsedBytes;计数器+1
            bufferNotEmpty.wakeAll();//唤醒全部线程
            mutex.unlock();//解锁
        }
    }
};

消费者类：

class Consumer : public QThread
{
    Q_OBJECT
public:
    Consumer(QObject *parent = NULL) : QThread(parent)
    {
    }

    void run() override
    {
        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;//计数器-1
            bufferNotFull.wakeAll();
            mutex.unlock();
        }
        fprintf(stderr, "\n");
    }

signals:
    void stringConsumed(const QString &text);
};

main函数：

int main(int argc, char *argv[])
{
    QCoreApplication app(argc, argv);
    Producer producer;//生产者
    Consumer consumer;//消费者
    producer.start();//开启线程
    consumer.start();//开启线程
    //两个线程调用wait()，阻塞线程，确保两个线程在退出前都有时间能完成main()
    producer.wait();
    consumer.wait();
    return 0;
}