Qt 线程

Qt中线程的解释： 

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

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

创建线程的方法：

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

继承QThread的特点：

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

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

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

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

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

 第一种创建方式：

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 常用的函数：

signals

例子：

主界面有，开启，暂停，关闭按钮，在一个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一起使用，才可以确保这可以轻松确保锁定和解锁的执行一致。

常用函数：

 QMutex：：QMutex（QMutex::RecursionMode mode)

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

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

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时，互斥锁被锁定。（更加方便）

函数：

 使用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(读-写锁)

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

函数：

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

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

 QSemaphore（信号量）

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

函数：

 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（）可以唤醒所有正在等待的线程

函数：

 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;
}