Qt 是一個(gè)跨平臺C++圖形界面開發(fā)庫，利用Qt可以快速開發(fā)跨平臺窗體應(yīng)用程序，在Qt中我們可以通過拖拽的方式將不同組件放到指定的位置，實(shí)現(xiàn)圖形化開發(fā)極大的方便了開發(fā)效率，本章將重點(diǎn)介紹如何運(yùn)用QThread組件實(shí)現(xiàn)多線程功能。

多線程技術(shù)在程序開發(fā)中尤為常用，Qt框架中提供了QThread庫來實(shí)現(xiàn)多線程功能。當(dāng)你需要使用QThread時(shí)，需包含QThread模塊，以下是QThread類的一些主要成員函數(shù)和槽函數(shù)。

當(dāng)我們需要?jiǎng)?chuàng)建線程時(shí)，通常第一步則是要繼承QThread類，并重寫類內(nèi)的run()方法，在run()方法中，你可以編寫需要在新線程中執(zhí)行的代碼。當(dāng)你創(chuàng)建一個(gè)QThread的實(shí)例并調(diào)用它的start()方法時(shí)，會自動調(diào)用run()來執(zhí)行線程邏輯，如下這樣一段代碼展示了如何運(yùn)用線程類。

#include <QCoreApplication>
#include <QThread>
#include <QDebug>

class MyThread : public QThread
{
public:
    void run() override
    {
        for (int i = 0; i < 5; ++i)
        {
            qDebug() << "Thread is running" << i;
            sleep(1);
        }
    }
};

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    MyThread thread;
    thread.start();
    thread.wait();

    qDebug() << "Main thread is done.";
    return a.exec();
}

上述代碼運(yùn)行后則會每隔1秒輸出一段話，在主函數(shù)內(nèi)通過調(diào)用thread.start方法啟動這個(gè)線程，并通過thread.wait等待線程結(jié)束，如下圖所示；

1.1 線程組與多線程

線程組是一種組織和管理多個(gè)線程的機(jī)制，允許將相關(guān)聯(lián)的線程集中在一起，便于集中管理、協(xié)調(diào)和監(jiān)控。通過線程組，可以對一組線程進(jìn)行統(tǒng)一的生命周期管理，包括啟動、停止、調(diào)度和資源分配等操作。

上述方法并未真正實(shí)現(xiàn)多線程功能，我們繼續(xù)完善MyThread自定義類，在該類內(nèi)增加兩個(gè)標(biāo)志，is_run()用于判斷線程是否正在運(yùn)行，is_finish()則用來判斷線程是否已經(jīng)完成，并在run()中增加打印當(dāng)前線程對象名稱的功能。

class MyThread: public QThread
{
protected:
    volatile bool m_to_stop;

protected:
    void run()
    {
        for(int x=0; !m_to_stop && (x <10); x++)
        {
            msleep(1000);
            std::cout << objectName().toStdString() << std::endl;
        }
    }

public:
    MyThread()
    {
        m_to_stop = false;
    }

    void stop()
    {
        m_to_stop = true;
    }

    void is_run()
    {
        std::cout << "Thread Running = " << isRunning() << std::endl;
    }

    void is_finish()
    {
        std::cout << "Thread Finished = " << isFinished() << std::endl;
    }

};

接著在主函數(shù)內(nèi)調(diào)整，增加一個(gè)MyThread thread[10]用于存儲線程組，線程組是一種用于組織和管理多個(gè)線程的概念。在不同的編程框架和操作系統(tǒng)中，線程組可能具有不同的實(shí)現(xiàn)和功能，但通常用于提供一種集中管理和協(xié)調(diào)一組相關(guān)線程的機(jī)制。

我們通過循環(huán)的方式依次對線程組進(jìn)行賦值，通過調(diào)用setObjectName對每一個(gè)線程賦予一個(gè)不同的名稱，當(dāng)需要使用這些線程時(shí)則可以通過循環(huán)調(diào)用run()方法來實(shí)現(xiàn)，而結(jié)束調(diào)用同樣如此，如下是調(diào)用的具體實(shí)現(xiàn)；

#include <QCoreApplication>
#include <iostream>
#include <QThread>

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    // 定義線程數(shù)組
    MyThread thread[10];

    // 設(shè)置線程對象名字
    for(int x=0;x<10;x++)
    {
        thread[x].setObjectName(QString("thread => %1").arg(x));
    }

    // 批量調(diào)用run執(zhí)行
    for(int x=0;x<10;x++)
    {
        thread[x].start();
        thread[x].is_run();
        thread[x].isFinished();
    }

    // 批量調(diào)用stop關(guān)閉
    for(int x=0;x<10;x++)
    {
        thread[x].wait();
        thread[x].stop();

        thread[x].is_run();
        thread[x].is_finish();
    }

    return a.exec();
}

如下圖則是運(yùn)行后實(shí)現(xiàn)的多線程效果；

1.2 向線程中傳遞參數(shù)

向線程中傳遞參數(shù)是多線程編程中常見的需求，不同的編程語言和框架提供了多種方式來實(shí)現(xiàn)這個(gè)目標(biāo)，在Qt中，由于使用的自定義線程類，所以可通過增加一個(gè)set_value()方法來向線程內(nèi)傳遞參數(shù)，由于線程函數(shù)內(nèi)的變量使用了protected屬性，所以也就實(shí)現(xiàn)了線程間變量的隔離，當(dāng)線程被執(zhí)行結(jié)束后則可以通過result()方法獲取到線程執(zhí)行結(jié)果，這個(gè)線程函數(shù)如下所示；

class MyThread: public QThread
{
protected:
    int m_begin;
    int m_end;
    int m_result;

    void run()
    {
        m_result = m_begin + m_end;
    }

public:
    MyThread()
    {
        m_begin = 0;
        m_end = 0;
        m_result = 0;
    }

    // 設(shè)置參數(shù)給當(dāng)前線程
    void set_value(int x,int y)
    {
        m_begin = x;
        m_end = y;
    }

    // 獲取當(dāng)前線程名
    void get_object_name()
    {
        std::cout << "this thread name => " << objectName().toStdString() << std::endl;
    }

    // 獲取線程返回結(jié)果
    int result()
    {
        return m_result;
    }
};

在主函數(shù)中，我們通過MyThread thread[3];來定義3個(gè)線程組，并通過循環(huán)三次分別thread[x].set_value()設(shè)置三組不同的參數(shù)，當(dāng)設(shè)置完成后則可以調(diào)用thread[x].start()方法運(yùn)行這些線程，線程運(yùn)行結(jié)束后則返回值將會被依次保存在thread[x].result()中，此時(shí)直接將其相加即可得到最終線程執(zhí)行結(jié)果；

#include <QCoreApplication>
#include <iostream>
#include <QThread>

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    MyThread thread[3];

    // 分別將不同的參數(shù)傳入到線程函數(shù)內(nèi)
    for(int x=0; x<3; x++)
    {
        thread[x].set_value(1,2);
        thread[x].setObjectName(QString("thread -> %1").arg(x));
        thread[x].start();
    }

    // 等待所有線程執(zhí)行結(jié)束
    for(int x=0; x<3; x++)
    {
        thread[x].get_object_name();
        thread[x].wait();
    }

    // 獲取線程返回值并相加
    int result = thread[0].result() + thread[1].result() + thread[2].result();
    std::cout << "sum => " << result << std::endl;

    return a.exec();
}

程序運(yùn)行后，則可以輸出三個(gè)線程相加的和；

1.3 互斥同步線程鎖

QMutex 是Qt框架中提供的用于線程同步的類，用于實(shí)現(xiàn)互斥訪問共享資源。Mutex是“互斥鎖（Mutual Exclusion）”的縮寫，它能夠確保在任意時(shí)刻，只有一個(gè)線程可以訪問被保護(hù)的資源，從而避免了多線程環(huán)境下的數(shù)據(jù)競爭和不一致性。

在Qt中，QMutex提供了簡單而有效的線程同步機(jī)制，其基本用法包括：

• 鎖定（Lock）： 線程在訪問共享資源之前，首先需要獲取QMutex的鎖，這通過調(diào)用lock()方法來實(shí)現(xiàn)。
• 解鎖（Unlock）： 當(dāng)線程使用完共享資源后，需要釋放QMutex的鎖，以允許其他線程訪問，這通過調(diào)用unlock()方法來實(shí)現(xiàn)。

該鎖lock()鎖定與unlock()解鎖必須配對使用，線程鎖保證線程間的互斥，利用線程鎖能夠保證臨界資源的安全性。

• 線程鎖解決的問題: 多個(gè)線程同時(shí)操作同一個(gè)全局變量，為了防止資源的無序覆蓋現(xiàn)象，從而需要增加鎖，來實(shí)現(xiàn)多線程搶占資源時(shí)可以有序執(zhí)行。
• 臨界資源(Critical Resource): 每次只允許一個(gè)線程進(jìn)行訪問 (讀/寫)的資源。
• 線程間的互斥(競爭): 多個(gè)線程在同一時(shí)刻都需要訪問臨界資源。
• 一般性原則: 每一個(gè)臨界資源都需要一個(gè)線程鎖進(jìn)行保護(hù)。

我們以生產(chǎn)者消費(fèi)者模型為例來演示鎖的使用方法，生產(chǎn)者消費(fèi)者模型是一種并發(fā)編程中常見的同步機(jī)制，用于解決多線程環(huán)境下的協(xié)作問題。該模型基于兩類角色：生產(chǎn)者（Producer）和消費(fèi)者（Consumer），它們通過共享的緩沖區(qū)進(jìn)行協(xié)作。

主要特點(diǎn)和工作原理如下：

1. 生產(chǎn)者：
   • 生產(chǎn)者負(fù)責(zé)產(chǎn)生一些資源或數(shù)據(jù)，并將其放入共享的緩沖區(qū)中。生產(chǎn)者在生產(chǎn)資源后，需要通知消費(fèi)者，以便它們可以取走資源。
2. 消費(fèi)者：
   • 消費(fèi)者從共享的緩沖區(qū)中取走資源，并進(jìn)行相應(yīng)的處理。如果緩沖區(qū)為空，消費(fèi)者需要等待，直到有新的資源可用。
3. 共享緩沖區(qū)：
   • 作為生產(chǎn)者和消費(fèi)者之間的交換介質(zhì)，共享緩沖區(qū)存儲被生產(chǎn)者產(chǎn)生的資源。它需要提供對資源的安全訪問，以防止競態(tài)條件和數(shù)據(jù)不一致性。
4. 同步機(jī)制：
   • 生產(chǎn)者和消費(fèi)者之間需要一些同步機(jī)制，以確保在正確的時(shí)機(jī)進(jìn)行資源的生產(chǎn)和消費(fèi)。典型的同步機(jī)制包括信號量、互斥鎖、條件變量等。

生產(chǎn)者消費(fèi)者模型的典型應(yīng)用場景包括異步任務(wù)處理、事件驅(qū)動系統(tǒng)、數(shù)據(jù)緩存等。這種模型的實(shí)現(xiàn)可以通過多線程編程或使用消息隊(duì)列等方式來完成。

首先在全局中引入#include <QMutex>庫，并在全局定義static QMutex線程鎖變量，接著我們分別定義兩個(gè)自定義線程函數(shù)，其中Producer代表生產(chǎn)者，而Customer則是消費(fèi)者，生產(chǎn)者中負(fù)責(zé)每次產(chǎn)出一個(gè)隨機(jī)數(shù)并將其追加到g_store全局變量內(nèi)保存，消費(fèi)者則通過g_store.remove每次取出一個(gè)元素。

static QMutex g_mutex;      // 線程鎖
static QString g_store;     // 定義全局變量

class Producer : public QThread
{
protected:
    void run()
    {
        int count = 0;

        while(true)
        {
            // 加鎖
            g_mutex.lock();

            g_store.append(QString::number((count++) % 10));
            std::cout << "Producer -> "<< g_store.toStdString() << std::endl;

            // 釋放鎖
            g_mutex.unlock();
            msleep(900);
        }
    }
};

class Customer : public QThread
{
protected:
    void run()
    {
        while( true )
        {
            g_mutex.lock();
            if( g_store != "" )
            {
                g_store.remove(0, 1);
                std::cout << "Curstomer -> "<< g_store.toStdString() << std::endl;
            }

            g_mutex.unlock();
            msleep(1000);
        }
    }
};

在主函數(shù)中分別定義兩個(gè)線程類，并依次運(yùn)行它們；

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    Producer p;
    Customer c;

    p.setObjectName("producer");
    c.setObjectName("curstomer");

    p.start();
    c.start();

    return a.exec();
}

至此，生產(chǎn)者產(chǎn)生數(shù)據(jù)，消費(fèi)者消費(fèi)數(shù)據(jù)；如下圖所示；

QMutexLocker 是Qt框架中提供的一個(gè)輔助類，它是在QMutex基礎(chǔ)上簡化版的線程鎖，QMutexLocker會保護(hù)加鎖區(qū)域，并自動實(shí)現(xiàn)互斥量的鎖定和解鎖操作，可以將其理解為是智能版的QMutex鎖，通過 QMutexLocker可以確保在作用域內(nèi)始終持有鎖，從而避免因?yàn)橥涐尫沛i而導(dǎo)致的問題。該鎖只需要在上方代碼中稍加修改即可。

使用 QMutexLocker 的一般流程如下：

1. 創(chuàng)建一個(gè) QMutex 對象。
2. 創(chuàng)建一個(gè) QMutexLocker 對象，傳入需要鎖定的 QMutex。
3. 在 QMutexLocker 對象的作用域內(nèi)進(jìn)行需要互斥訪問的操作。
4. 當(dāng) QMutexLocker 對象超出作用域范圍時(shí)，會自動釋放鎖。

static QMutex g_mutex;      // 線程鎖
static QString g_store;     // 定義全局變量

class Producer : public QThread
{
protected:
    void run()
    {
        int count = 0;

        while(true)
        {
			// 增加智能線程鎖
            QMutexLocker Locker(&g_mutex);

            g_store.append(QString::number((count++) % 10));
            std::cout << "Producer -> "<< g_store.toStdString() << std::endl;

            msleep(900);
        }
    }
};

1.4 讀寫同步線程鎖

QReadWriteLock 是Qt框架中提供的用于實(shí)現(xiàn)讀寫鎖的類。讀寫鎖允許多個(gè)線程同時(shí)讀取共享數(shù)據(jù)，但在寫入數(shù)據(jù)時(shí)會互斥，確保數(shù)據(jù)的一致性和完整性。這對于大多數(shù)情況下讀取頻繁而寫入較少的共享數(shù)據(jù)非常有用，可以提高程序的性能。

其提供了兩種鎖定操作：

• 讀取鎖（Read Lock）： 允許多個(gè)線程同時(shí)獲取讀取鎖，用于并行讀取共享數(shù)據(jù)。在沒有寫入鎖的情況下，多個(gè)線程可以同時(shí)持有讀取鎖。
• 寫入鎖（Write Lock）： 寫入鎖是互斥的，當(dāng)一個(gè)線程獲取寫入鎖時(shí)，其他線程無法獲取讀取鎖或?qū)懭腈i。這確保了在寫入數(shù)據(jù)時(shí)，不會有其他線程同時(shí)讀取或?qū)懭搿?/li>

互斥鎖存在一個(gè)問題，每次只能有一個(gè)線程獲得互斥量的權(quán)限，如果在程序中有多個(gè)線程來同時(shí)讀取某個(gè)變量，那么使用互斥量必須排隊(duì)，效率上會大打折扣，基于QReadWriteLock讀寫模式進(jìn)行代碼段鎖定，即可解決互斥鎖存在的問題。

#include <QCoreApplication>
#include <iostream>
#include <QThread>
#include <QMutex>
#include <QReadWriteLock>

static QReadWriteLock g_mutex;      // 線程鎖
static QString g_store;             // 定義全局變量

class Producer : public QThread
{
protected:
    void run()
    {
        int count = 0;

        while(true)
        {
            // 以寫入方式鎖定資源
            g_mutex.lockForWrite();

            g_store.append(QString::number((count++) % 10));

            // 寫入后解鎖資源
            g_mutex.unlock();

            msleep(900);
        }
    }
};

class Customer : public QThread
{
protected:
    void run()
    {
        while( true )
        {
            // 以讀取方式寫入資源
            g_mutex.lockForRead();
            if( g_store != "" )
            {
                std::cout << "Curstomer -> "<< g_store.toStdString() << std::endl;
            }

            // 讀取到后解鎖資源
            g_mutex.unlock();
            msleep(1000);
        }
    }
};

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    Producer p1,p2;
    Customer c1,c2;

    p1.setObjectName("producer 1");
    p2.setObjectName("producer 2");

    c1.setObjectName("curstomer 1");
    c2.setObjectName("curstomer 2");

    p1.start();
    p2.start();

    c1.start();
    c2.start();

    return a.exec();
}

該鎖允許用戶以同步讀lockForRead()或同步寫lockForWrite()兩種方式實(shí)現(xiàn)保護(hù)資源，但只要有一個(gè)線程在以寫的方式操作資源，其他線程也會等待寫入操作結(jié)束后才可繼續(xù)讀資源。

1.5 基于信號線程鎖

QSemaphore 是Qt框架中提供的用于實(shí)現(xiàn)信號量的類。信號量是一種用于在線程之間進(jìn)行同步和通信的機(jī)制，它允許多個(gè)線程在某個(gè)共享資源上進(jìn)行協(xié)調(diào)，控制對該資源的訪問。QSemaphore 的主要作用是維護(hù)一個(gè)計(jì)數(shù)器，線程可以通過獲取和釋放信號量來改變計(jì)數(shù)器的值。

其主要方法包括：

• QSemaphore(int n = 0)：構(gòu)造函數(shù)，創(chuàng)建一個(gè)初始計(jì)數(shù)值為 n 的信號量。
• void acquire(int n = 1)：獲取信號量，將計(jì)數(shù)器減去 n。如果計(jì)數(shù)器不足，線程將阻塞等待。
• bool tryAcquire(int n = 1)：嘗試獲取信號量，如果計(jì)數(shù)器足夠，立即獲取并返回 true；否則返回 false。
• void release(int n = 1)：釋放信號量，將計(jì)數(shù)器加上 n。如果有等待的線程，其中一個(gè)將被喚醒。

信號量是特殊的線程鎖，信號量允許N個(gè)線程同時(shí)訪問臨界資源，通過acquire()獲取到指定資源，release()釋放指定資源。文章來源地址http://www.zghlxwxcb.cn/news/detail-837863.html

#include <QCoreApplication>
#include <iostream>
#include <QThread>
#include <QSemaphore>

const int SIZE = 5;
unsigned char g_buff[SIZE] = {0};

QSemaphore g_sem_free(SIZE); // 5個(gè)可生產(chǎn)資源
QSemaphore g_sem_used(0);    // 0個(gè)可消費(fèi)資源

// 生產(chǎn)者生產(chǎn)產(chǎn)品
class Producer : public QThread
{
protected:
    void run()
    {
        while( true )
        {
            int value = qrand() % 256;

            // 若無法獲得可生產(chǎn)資源，阻塞在這里
            g_sem_free.acquire();

            for(int i=0; i<SIZE; i++)
            {
                if( !g_buff[i] )
                {
                    g_buff[i] = value;
                    std::cout << objectName().toStdString() << " --> " << value << std::endl;
                    break;
                }
            }

            // 可消費(fèi)資源數(shù)+1
            g_sem_used.release();

            sleep(2);
        }
    }
};

// 消費(fèi)者消費(fèi)產(chǎn)品
class Customer : public QThread
{
protected:
    void run()
    {
        while( true )
        {
            // 若無法獲得可消費(fèi)資源，阻塞在這里
            g_sem_used.acquire();

            for(int i=0; i<SIZE; i++)
            {
                if( g_buff[i] )
                {
                    int value = g_buff[i];

                    g_buff[i] = 0;
                    std::cout << objectName().toStdString() << " --> " << value << std::endl;
                    break;
                }
            }

            // 可生產(chǎn)資源數(shù)+1
            g_sem_free.release();

            sleep(1);
        }
    }
};

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    Producer p1;
    Customer c1;

    p1.setObjectName("producer");
    c1.setObjectName("curstomer");

    p1.start();
    c1.start();

    return a.exec();
}

到了這里，關(guān)于C++ Qt開發(fā)：運(yùn)用QThread多線程組件的文章就介紹完了。如果您還想了解更多內(nèi)容，請?jiān)谟疑辖撬阉鱐OY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！