Qt でのスレッドの同期と相互排他

スレッド同期の基本

重要なリソース:每次只允许一个线程进行访问的资源

スレッド間の相互排他:多个线程在同一时刻都需要访问临界资源

スレッド ロックにより、重要なリソースのセキュリティを確保できます。通常、各重要なリソースには保護のためにスレッド ロックが必要です。

スレッドのデッドロック:线程间相互等待临界资源而造成彼此无法继续执行。

デッドロックの条件:

A. システム内に複数の重要なリソースがあり、重要なリソースをプリエンプトすることはできません。

B. スレッドが実行を継続するには複数の重要なリソースが必要です

デッドロックの回避:

A. 使用される重要なリソースごとに一意のシリアル番号を割り当てます。

B. 各重要なリソースに対応するスレッド ロックに、対応するシーケンス番号を割り当てます。

C. システム内の各スレッドは厳密に昇順で重要なリソースを要求します

        QMutex、QReadWriteLock、QSemaphore、QWaitCondition は スレッド同期の手段を提供します。スレッドを使用する主な考え方は、スレッドが可能な限り同時に実行されることを期待することであり、スレッドはいくつかの重要なポイントの間で停止または待機する必要があります。たとえば、2 つのスレッドが同時に同じグローバル変数にアクセスしようとすると、結果が期待どおりにならない可能性があります。

ミューテックス Qミューテックス

        QMutex は、相互排他的なロック、つまりミューテックスを提供します。ミューテックスを所有するスレッドは一度に最大 1 つです。スレッドがロックされたミューテックスにアクセスしようとすると、ミューテックスを所有するスレッドがミューテックスのロックを解除するまで、スレッドはスリープ状態になります。QMutex は、共有データへのアクセスを保護するために一般的に使用されます。QMutex クラスなので、メンバー関数はスレッドセーフです。

头文件声明：#include <QMutex>

互斥量声明：QMutex m_Mutex;

互斥量加锁：m_Mutex.lock();

互斥量解锁：m_Mutex.unlock();

        ロックされていないミューテックスがロック解除された場合、結果は不明です。

シナリオ例:

QThread クラスを継承してマルチスレッドを実現する

#ifndef MYTHREAD_H
#define MYTHREAD_H
#include <QObject>
#include <QThread>

class MyThread :public QThread
{
    Q_OBJECT
public:
    MyThread();
protected:
    virtual void run();
private:
};
#endif // MYTHREAD_H

#include "mythread.h"
#include <QDebug>
externint global_Val;
MyThread::MyThread()
{
    qDebug()<<"mainThread::currentId:"<<QThread::currentThreadId();
}

void MyThread::run()
{
    while (global_Val>0) {
        qDebug()<<"threadId:"<< QThread::currentThreadId()<<"  global_val:"<<global_Val--;
//        QThread::msleep(200);
    }
    qDebug()<<"Task finish";
}

#include <QCoreApplication>
#include "mythread.h"
int global_Val = 10;
int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    MyThread thread1,thread2;
    thread1.start();
    thread2.start();
    return a.exec();
}

        2 つのスレッドからアクセスできるグローバル変数を定義します。2 つのスレッドが同時にアクセスすると、リソースの競合が発生し、予測不可能なエラーが発生します。

プログラムを実行した結果は次のようになります

mainThread::currentId: 0x222c
mainThread::currentId: 0x222c
threadId: 0x3df4   global_val: 10
threadId: 0x3df4   global_val: 8
threadId: 0x3df4   global_val: 7
threadId: 0x10b8   global_val: 9
threadId: 0x3df4   global_val: 6
threadId: 0x10b8   global_val: 5
threadId: 0x3df4   global_val: 4
threadId: 0x3df4   global_val: 2
threadId: 0x3df4   global_val: 1
threadId: 0x10b8   global_val: 3
Task finish
Task finish

データが乱雑であることがわかります。これはロックなしの場合であり、ロックを追加します。

#include "mythread.h"
#include <QDebug>
externint global_Val;
extern QMutex globlMutex;   //锁一定是全局的
MyThread::MyThread()
{
    qDebug()<<"mainThread::currentId:"<<QThread::currentThreadId();
}

void MyThread::run()
{
    while (global_Val>0) {
        globlMutex.lock();
        qDebug()<<"threadId:"<< QThread::currentThreadId()<<"  global_val:"<<global_Val--;
//        QThread::msleep(200);
        globlMutex.unlock();
    }
    qDebug()<<"Task finish";
}

        ミューテックスのロックとロック解除は、同じスレッド内でペアで行う必要があります。

        実行後、リソースの取得やデータの損失などの問題は発生しません。

mainThread::currentId: 0x3b28
mainThread::currentId: 0x3b28
threadId: 0x1ae8   global_val: 10
threadId: 0x1024   global_val: 9
threadId: 0x1ae8   global_val: 8
threadId: 0x1024   global_val: 7
threadId: 0x1ae8   global_val: 6
threadId: 0x1024   global_val: 5
threadId: 0x1ae8   global_val: 4
threadId: 0x1024   global_val: 3
threadId: 0x1ae8   global_val: 2
threadId: 0x1024   global_val: 1
Task finish
threadId: 0x1ae8   global_val: 0
Task finish

10 が小さすぎると感じる場合は、100 に変更できます。ロック解除の場合、データ損失はさらに深刻になります。

ミューテックス QMutexLocker

        より複雑な関数や例外処理でQMutexクラスオブジェクトに対してmutexlock() および lock() 操作を実行することは非常に複雑になります。エントリ ポイントはlock()すべての終了ポイントで必要ですunlock()。一部の終了ポイントが呼び出されないように見えるのは簡単ですunlock()。 Qt QMutex の補助クラスQMutexLocker は、lock()および) 操作を回避するために導入されましたunlock(。関数が必要とするオブジェクトを作成しQMutexLocker、オブジェクトmutexへのポインタを渡します。この時点で、ミューテックスはロックされています。関数を終了すると、 QMutexLockerオブジェクトのローカル変数は自動的に破棄され、ミューテックスは現時点ではロック解除されています。QMutexLocker

头文件声明：    #include<QMutexLocker>

互斥锁声明：    QMutexLocker mutexLocker(&m_Mutex);

互斥锁加锁：    从声明处开始（在构造函数中加锁）

互斥锁解锁：    出了作用域自动解锁（在析构函数中解锁）

ミューテックスを使用したスレッド同期

#include "mythread.h"
#include <QDebug>
externint global_Val;
extern QMutex globlMutex;   //锁一定是全局的
MyThread::MyThread()
{
    qDebug()<<"mainThread::currentId:"<<QThread::currentThreadId();
}

void MyThread::run()
{
    while (global_Val>0) {
        QMutexLocker locker(&globlMutex);
        qDebug()<<"threadId:"<< QThread::currentThreadId()<<"  global_val:"<<global_Val--;
//        QThread::msleep(200);
    }
    qDebug()<<"Task finish";
}

条件変数 QWaitCondition

        Qt では待機条件と呼ばれますが、Linux では条件変数と呼ばれますが、ここでは一律に条件変数と呼びます。

        QWaitCondition を 使用すると、特定の条件が発生したときにスレッドが他のスレッドをウェイクアップできます。1 つ以上のスレッドが待機をブロックしたりQWaitCondition 、wakeOne()or wでakeAll()条件を設定したりできます。wakeOne()随机唤醒一个，wakeAll()唤醒所有。

QWaitCondition ()

bool wait ( QMutex * mutex, unsigned long time = ULONG_MAX )

bool wait ( QReadWriteLock * readWriteLock, unsigned long time = ULONG_MAX )

void wakeOne ()

void wakeAll ()

头文件声明：    #include <QWaitCondition>

等待条件声明：    QWaitCondtion m_WaitCondition;

等待条件等待：    m_WaitConditon.wait(&m_muxtex, time);

等待条件唤醒：    m_WaitCondition.wakeAll();

        古典的なプロデューサーとコンシューマーのシナリオでは、プロデューサーは最初にバッファーがいっぱいかどうかを確認する必要があります。バッファーがいっぱいの場合、スレッドは停止し、  notfull状態になるまで待機します。いっぱいでない場合は、バッファーにデータを生成し、条件 nottemptyをアクティブにします。mutexへのアクセスを保護するために使用しますbuffer。パラメータとしてQWaitCondition::wait() 1 を受け取ると、呼び出されたスレッドはロック状態に初期化されます。スレッドがスリープ状態になる前に、ロックが解除されます。スレッドがウェイクアップされると、スレッドはロック状態になり、ロック状態から待機状態への遷移はアトミックな操作になります。プログラムが実行を開始すると、プロデューサーのみが動作でき、コンシューマーはnottempty条件の待機中にブロックされます。プロデューサーがバッファーにバイトを入れると、nottempty条件が発生し、コンシューマー スレッドが起動されます。mutexmutexmutexmutex

生産者と消費者の例:

#include <QtCore/QCoreApplication>
#include <QThread>
#include <QWaitCondition>
#include <QMutex>
#include <QDebug>
#define BUFFER_SIZE 2

/*生产者*/
class producons
{
public:
    int buffer[BUFFER_SIZE];    /*数据*/
    QMutex lock;                //互斥锁
    int readpos,writepos;       //读写位置
    QWaitCondition nottempty;   //条件变量  没有空间
    QWaitCondition notfull;     //条件变量  没有货物

    producons()
    {
        readpos = writepos = 0;
    }
};
producons buffer;    //生产者对象

class Producor:public QThread
{
public:
    void run();
    void put(producons * prod,int data);
};

void Producor::run()
{
    int n;
    for(n = 0;n<5;n++)
    {
        qDebug()<<"生产者睡眠 1s...";
        sleep(1);
        qDebug()<<"生产信息:" << n;
        put(&buffer, n);
    }
    for(n=5; n<10; n++)
    {
        qDebug()<<"生产者睡眠 3s...";
        sleep(3);
        qDebug()<<"生产信息："<< n;
        put(&buffer,n);
    }
    put(&buffer, -1);
    qDebug()<<"结束生产者!\n";
    return;
}
void Producor::put(producons *prod, int data)
{
    prod->lock.lock();

    //write until buffer not full
    while((prod->writepos + 1)%BUFFER_SIZE == prod->readpos)
    {
        qDebug()<<"生产者等待生产，直到buffer有空位置";
        prod->notfull.wait(&prod->lock);
    }
    //将数据写入到buffer里面去
    prod->buffer[prod->writepos] = data;
    prod->writepos++;
    if(prod->writepos >= BUFFER_SIZE)
        prod->writepos = 0;
    //仓库已满，等待消费者消费
    prod->nottempty.wakeAll();
    prod->lock.unlock();
}

class Consumer:public QThread
{
public:
    void run();
    int get(producons *prod);
};

void Consumer::run()
{
    int d = 0;
    while(1)
    {
        qDebug()<<"消费者睡眠 2s...";
        sleep(2);
        d = get(&buffer);
        qDebug()<<"读取信息:"<< d;
        if(d == -1) break;
    }
    qDebug()<<"结束消费者!";
    return;
}

int Consumer::get(producons *prod)
{
    int data;
    prod->lock.lock();      //加锁

    while(prod->writepos == prod->readpos)
    {
        qDebug()<<"消费者等待，直到buffer有消息\n";
        prod->nottempty.wait(&prod->lock);
    }
    //读取buffer里面的消息
    data = prod->buffer[prod->readpos];
    prod->readpos++;

    if(prod->readpos >=BUFFER_SIZE)
        prod->readpos = 0;
    //触发非满条件变量 告诉生产者可以生产
    prod->notfull.wakeAll();
    prod->lock.unlock();

    return data;
}
int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    Producor productor;
    Consumer consumer;
    productor.start();
    consumer.start();
    productor.wait();
    consumer.wait();
    return a.exec();
}

生产者睡眠 1s...
消费者睡眠 2s...
生产信息: 0
生产者睡眠 1s...
读取信息: 0
生产信息: 1
消费者睡眠 2s...
生产者睡眠 1s...
生产信息: 2
生产者等待生产，直到buffer有空位置
读取信息: 1
生产者睡眠 1s...
消费者睡眠 2s...
生产信息: 3
生产者等待生产，直到buffer有空位置
读取信息: 2
生产者睡眠 1s...
消费者睡眠 2s...
生产信息: 4
生产者等待生产，直到buffer有空位置
读取信息: 3
生产者睡眠 3s...
消费者睡眠 2s...
读取信息: 4
消费者睡眠 2s...
生产信息： 5
生产者睡眠 3s...
读取信息: 5
消费者睡眠 2s...
生产信息： 6
消费者等待，直到buffer有消息

生产者睡眠 3s...
读取信息: 6
消费者睡眠 2s...
消费者等待，直到buffer有消息

生产信息： 7
生产者睡眠 3s...
读取信息: 7
消费者睡眠 2s...
消费者等待，直到buffer有消息

生产信息： 8
生产者睡眠 3s...
读取信息: 8
消费者睡眠 2s...
消费者等待，直到buffer有消息

生产信息： 9
生产者等待生产，直到buffer有空位置
读取信息: 9
消费者睡眠 2s...
结束生产者!

読み書きロック QReadWriteLock

        QReadWriterLock に似ていますQMutexが、読み取り操作と書き込み操作の処理が異なるため、複数のリーダーが同時にデータを読み取ることができますが、書き込みを行うのは 1 つだけであり、書き込み操作と読み取り操作は同時に実行されません。QReadWriteLockの代わりに を使用するとQMutex、マルチスレッド プログラムの同時実行性を高めることができます。QReadWriterLock のデフォルト モードは次のとおりです。NonRecursive

QReadWriterLock クラスのメンバー関数は次のとおりです。

QReadWriteLock ( )
QReadWriteLock ( RecursionMode recursionMode )
void lockForRead ()
void lockForWrite ()
bool tryLockForRead ()
bool tryLockForRead ( int timeout )
bool tryLockForWrite ()
bool tryLockForWrite ( int timeout )
boid unlock ()

使用例:

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

QReadLocker と QWriteLocker

        より複雑な関数や例外処理では、QReadWriterLockクラスlockオブジェクトの操作lockForRead()/lockForWrite()と操作が非常に複雑になります。すべての終了ポイントでunlock()エントリ ポイントが必要です。一部の終了ポイントが呼び出されないように見えるため、Qt ではQReadLockerとQWriteLockerクラス : ロック解除操作を簡素化します。関数が必要とするQReadLockerまたはQWriteLockerオブジェクトを作成し、ロックポインターをQReadLockerまたはQWriteLockerオブジェクトに渡します。この時点では、ロックはロックされています。関数を終了した後、またはオブジェクトのローカル変数は次の関数によって破棄されます。この時点でロックは解除されます。lockForRead()/lockForWrite()unlock()unlock()QReadLockerQWriteLocker

QReadWriteLock lock;
QByteArray readData()
{
    QReadLocker locker(&lock);
    ...
    return data;
}

セマフォ Qセマフォ

        QSemaphore はQMutexを一般化したもので、複数のスレッドが重要なリソースに同時にアクセスできるようにし、1 つのQMutex重要なリソースのみを保護する特別なスレッド ロックです。QSemaphore クラスのすべてのメンバー関数はスレッドセーフです。

QSemaphore クラスのメンバー関数:

QSemaphore ( int n = 0 )
void acquire ( int n = 1 )
int available () const
void release ( int n = 1 )
bool tryAcquire ( int n = 1 )
bool tryAcquire ( int n, int timeout )

疑似コード:

constint BufferSize = 8192;
QSemaphore  production(BufferSize);
QSemaphore  consumption;

production.acquire();
//对BufferSize锁着后操作
consumption.release();