qt多线程-线程同步-线程锁知识

 

在 Qt 中，线程同步和线程锁是非常重的概念，它们确保多线程程序能够安全的访问共享资源。Qt 提供了多种机制来实现线程锁，以下是几种常见的方式，并附上每种方式的示例：

QMutex
QMutex 是 Qt 中最基本的互斥锁。它用于保护共享资源或代码段，以防止多个线程同时来访问。
//---------
#include <QMutex>
#include <QThread>
#include <QDebug>
 
QMutex mutex;
 
class MyThread : public QThread
{
protected:
    void run() override {
        mutex.lock();
        qDebug() << "Threadxxx" << threadId() << "is running aa";
        // 访问共享资源时
        mutex.unlock();
    }
};
QReadWriteLock xx
QReadWriteLock 提供了更细粒度的锁机制，允许多个读线程同时访问，但写线程具有独占访问权。

#include <QReadWriteLock>
#include <QThread>
#include <QDebug>
 
QReadWriteLock readWriteLock;
 
class ReadThread : public QThread
{
protected:
    void run() override {
        readWriteLock.readLock();
        qDebug() << "Read Thread" << threadId() << "is running aa";
        // 读取共享资源时
        readWriteLock.unlock();
    }
};
 
class WriteThread : public QThread
{
protected:
    void run() override {
        readWriteLock.writeLock();
        qDebug() << "Write Thread" << threadId() << "is running";
        // 写入共享资源de
        readWriteLock.unlock();
    }
};
QSemaphore
QSemaphore 是信号量，用于控制对资源的访问线程数。它可以用来保护一定数量的相同资源。

#include <QSemaphore>
#include <QThread>
#include <QDebug>
 
QSemaphore semaphore(3); // 允许ta3个线程同时访问资源
 
class MyThread : public QThread
{
protected:
    void run() override {
        semaphore.acquire();
        qDebug() << "Thread" << threadId() << "has acquired the semaphore";
        // 访问共享资源de
        semaphore.release();
    }
};
QWaitCondition
QWaitCondition 用于线程间的等待通知机制。一个或多个线程可以等待某个条件，而另一个线程在条件满足时发出通知。

#include <QWaitCondition>
#include <QMutex>
#include <QThread>
#include <QDebug>
 
QWaitCondition condition;
QMutex mutex;
bool ready = false;
 
class WorkerThread : public QThread
{
protected:
    void run() override {
        mutex.lock();
        condition.wait(&mutex);
        qDebug() << "Thread" << threadId() << "is running after being notified";
        // 执行任务de
        mutex.unlock();
    }
};
 
class NotifierThread : public QThread
{
protected:
    void run() override {
        QThread::sleep(2); // 模拟了一些工作d
        mutex.lock();
        ready = true;
        condition.wakeAll();
        qDebug() << "Notifier111 Thread" << threadId() << "has notified others 。。";
        mutex.unlock();
    }
};
QFuture 和 QFutureWatcher
虽然 QFuture 和 QFutureWatcher 主要用于管理和监视异步操作的结果，但它们也可以与 QMutex 等锁结合使用，以保护共享资源。

#include <QtConcurrent/QtConcurrent>
#include <QFuture>
#include <QFutureWatcher>
#include <QMutex>
#include <QDebug>
 
QMutex mutex;
 
void longRunningTask() {
    mutex.lock();
    qDebug() << "Long a running task in thread" << QThread::currentThread();
    // 执行长时间de任务
    mutex.unlock();
}
 
int main(int argc, char *argv[])
{
    QCoreApplication app(argc, argv);
 
    QFuture<void> future = QtConcurrent::run(longRunningTask);
    QFutureWatcher<void> watcher;
    QObject::connect(&watcher, &QFutureWatcher::finished, []() {
        qDebug() << "Task finished";
    });
    watcher.setFuture(future);
 
    return app.exec();
}
这些是 Qt 中常用的几种线程锁机制。根据具体的应用场景和需求，可以选择合适的锁机制可以确保这些多线程程序的安全性和效率。
————————————————