Qt/C++ 多线程同步机制详解及应用

🕗 发布于 2024-09-21 03:59 qt c++ java

在多线程编程中，线程之间共享资源可能会导致数据竞争和不一致的问题。因此，采用同步机制确保线程安全至关重要。在Qt/C++中，常见的同步机制有：互斥锁（QMutex、std::mutex）、信号量（QSemaphore）、读写锁（QReadWriteLock）、原子操作（QAtomicInt 等）以及条件变量（QWaitCondition、std::condition_variable）。本文将详细介绍这些常用同步机制，并通过代码示例帮助理解其使用场景。

在这里插入图片描述

1. 互斥锁（`QMutex` / `std::mutex`）

互斥锁是最常用的线程同步机制之一，它可以保证在同一时刻只有一个线程进入临界区。其基本原理是通过锁定和解锁互斥锁来确保共享资源的独占访问。

示例代码及注释

#include <QMutex>
#include <QThread>
#include <iostream>

// 声明一个全局互斥锁，用于保护共享资源
QMutex mutex;
int sharedResource = 0;  // 共享资源

class Worker : public QThread {
public:
    void run() override {
        mutex.lock();  // 锁定互斥锁，确保当前线程独占资源
        std::cout << "Thread " << QThread::currentThreadId() << " is entering the critical section." << std::endl;
        sharedResource++;  // 修改共享资源
        std::cout << "Shared Resource: " << sharedResource << std::endl;
        mutex.unlock();  // 释放互斥锁，其他线程可以进入
    }
};

int main() {
    Worker worker1, worker2;  // 创建两个工作线程
    worker1.start();  // 启动第一个线程
    worker2.start();  // 启动第二个线程
    worker1.wait();   // 等待第一个线程完成
    worker2.wait();   // 等待第二个线程完成
    return 0;
}

解释：

互斥锁机制：使用 mutex.lock() 锁定，mutex.unlock() 解锁，保证共享资源在某个线程执行完后才可被其他线程访问。
线程独占性：多个线程同时访问共享资源时，只有获取到锁的线程能进入临界区，避免竞争条件。

2. 信号量（`QSemaphore`）

信号量是一种同步机制，用于控制多个线程同时访问有限数量的资源。与互斥锁不同，信号量可以允许多个线程并发访问，直到信号量资源用尽。

示例代码及注释

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

// 初始化信号量，允许最多3个线程同时进入临界区
QSemaphore semaphore(3);

class Worker : public QThread {
public:
    void run() override {
        semaphore.acquire();  // 获取信号量
        std::cout << "Thread " << QThread::currentThreadId() << " is entering." << std::endl;
        QThread::sleep(1);    // 模拟执行任务的时间
        std::cout << "Thread " << QThread::currentThreadId() << " is leaving." << std::endl;
        semaphore.release();  // 释放信号量
    }
};

int main() {
    Worker worker1, worker2, worker3, worker4;  // 创建四个线程
    worker1.start();  // 启动线程
    worker2.start();
    worker3.start();
    worker4.start();  // 第四个线程需等待其他线程释放信号量
    worker1.wait();
    worker2.wait();
    worker3.wait();
    worker4.wait();
    return 0;
}

解释：

并发控制：信号量通过 acquire() 获取资源，release() 释放资源，控制多个线程并发执行。
资源计数：当信号量值为零时，其他线程必须等待信号量被释放才能继续执行。

3. 读写锁（`QReadWriteLock`）

读写锁允许多个线程同时读取共享资源，但只有一个线程可以进行写入操作。它适合在多读少写的场景中使用，能有效提高读取操作的并发性能。

示例代码及注释

#include <QReadWriteLock>
#include <QThread>
#include <iostream>

// 读写锁，保护共享资源
QReadWriteLock lock;
int sharedResource = 0;  // 共享资源

class Reader : public QThread {
public:
    void run() override {
        lock.lockForRead();  // 获取读锁
        std::cout << "Reader thread " << QThread::currentThreadId() << " reading: " << sharedResource << std::endl;
        lock.unlock();  // 释放读锁
    }
};

class Writer : public QThread {
public:
    void run() override {
        lock.lockForWrite();  // 获取写锁
        sharedResource++;
        std::cout << "Writer thread " << QThread::currentThreadId() << " writing: " << sharedResource << std::endl;
        lock.unlock();  // 释放写锁
    }
};

int main() {
    Reader reader1, reader2;  // 创建两个读线程
    Writer writer1;  // 创建一个写线程
    reader1.start();
    reader2.start();
    writer1.start();  // 写线程将阻塞后续的读操作
    reader1.wait();
    reader2.wait();
    writer1.wait();
    return 0;
}

解释：

多读单写：lock.lockForRead() 允许多个线程同时读取，而 lock.lockForWrite() 则保证写操作期间的独占访问。
适用场景：在多读少写的场景下，读写锁可以提高效率。

4. 原子操作（`QAtomicInt` / `std::atomic`）

原子操作是一种无需锁定的同步方式，适合处理简单的共享数据操作，如计数器的增减。它通过硬件保证操作的原子性，从而避免了线程间的数据竞争。

示例代码及注释

#include <QAtomicInt>
#include <QThread>
#include <iostream>

// 原子整型，用于原子递增
QAtomicInt atomicCounter = 0;

class Worker : public QThread {
public:
    void run() override {
        for (int i = 0; i < 1000; ++i) {
            atomicCounter.ref();  // 原子递增操作
        }
    }
};

int main() {
    Worker worker1, worker2;  // 创建两个线程
    worker1.start();
    worker2.start();
    worker1.wait();
    worker2.wait();
    std::cout << "Final counter: " << atomicCounter.load() << std::endl;  // 输出最终的计数值
    return 0;
}

解释：

轻量同步：atomicCounter.ref() 是一个原子操作，不需要使用互斥锁，适合简单的递增或递减操作。
性能提升：相比于使用锁，原子操作的性能开销更小，非常适合对共享资源进行计数的场景。

5. 条件变量（`QWaitCondition` / `std::condition_variable`）

条件变量用于线程间的同步，它允许线程等待某个条件被满足，通常与互斥锁一起使用。在条件满足时，可以唤醒一个或多个等待的线程。

示例代码及注释

#include <QMutex>
#include <QWaitCondition>
#include <QThread>
#include <iostream>

// 声明互斥锁和条件变量
QMutex mutex;
QWaitCondition condition;
bool ready = false;  // 条件标志

class Worker : public QThread {
public:
    void run() override {
        mutex.lock();  // 获取互斥锁
        while (!ready) {
            condition.wait(&mutex);  // 等待条件满足，期间释放互斥锁
        }
        std::cout << "Thread " << QThread::currentThreadId() << " is processing." << std::endl;
        mutex.unlock();  // 释放互斥锁
    }
};

int main() {
    Worker worker1, worker2;  // 创建两个线程
    worker1.start();
    worker2.start();
    
    QThread::sleep(1);  // 模拟主线程准备时间
    mutex.lock();
    ready = true;
    condition.wakeAll();  // 唤醒所有等待的线程
    mutex.unlock();

    worker1.wait();
    worker2.wait();
    return 0;
}

解释：

条件等待：线程使用 condition.wait() 进入等待状态，直到条件满足时被唤醒。
唤醒机制：condition.wakeAll() 唤醒所有正在等待条件的线程，使它们重新进入竞争状态。

在多线程编程中，选择合适的同步机制是确保数据安全和程序高效运行的关键。根据不同的应用场景，互斥锁、信号量、读写锁、原子操作和条件变量各有优缺点：

互斥锁 适用于保护临界区，确保共享资源的独占访问；
信号量 控制并发资源的访问数量；
读写锁 适合多读少写的场景，提升读取性能；
原子操作 在简单的共享数据操作中高效且轻量；
条件变量 允许线程等待某个条件的满足，以实现灵活的线程同步。

合理使用这些工具能够有效避免多线程编程中的竞争条件，确保程序的安全和性能。

原文地址：https://blog.csdn.net/chenai886/article/details/142393335

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：EI-BISYNCH协议，欧陆2000系列设备读取数据
下一篇：IP Source Guard技术原理与应用

rabbitmq 短信验证码
新建一个springboot项目,引入web，redis，rabbitmq。
阅读更多2024-09-21
tomcat中间件漏洞CVE-2017-12615，后台弱口令部署war包，CVE-2020-1938
2. ⽂件上传成功后，默认会在⽹站根⽬录下⽣成和war包名称⼀致得⽬录，然后⽬录中得⽊⻢就是压缩前的⽂件名。漏洞复现 http://172.16.1.22:8080/manager/html。制作W
阅读更多2024-09-21
力扣 438找到字符串中所有字母异位词
通过滑动窗口进行遍历，通过"hash"将字符串子串映射到异位词表示空间每一个表示代表了一个异位词空间(一个字符串的所有元素的全排列广义上讲，以上方法都属于一种hash。
阅读更多2024-09-21
数据结构 - 树与二叉树
/数据域//左结点与右结点的指针。
阅读更多2024-09-21
【STL】map和set相关知识详细梳理
1. set是按照一定次序存储元素的容器。2. 在set中，元素的value就是key，并且每个value必须是唯一的。set中的元素不能在容器中修改(元素总是const)，但是可以从容器中插入或删除
阅读更多2024-09-21
Day4:杨辉三角
题目：给定一个非负整数numRows,生成杨辉三角的前numRows行。在杨辉三角中，每个数就是左上方和右上方数的和。
阅读更多2024-09-21
Android Retrofit源码分析（一）：Retrofit是什么？和OkHttp的区别是什么？为什么需要他？
为什么会出现Retrofit？它的作用是什么？
阅读更多2024-09-21
微服务远程调用（nacos及OpenFeign简单使用）
问题：在微服务中，每个项目是隔离开的，当有一个项目请求其他项目中的数据时，必须发起网络请求，本文即对此问题展开讨论。
阅读更多2024-09-21
数字签名和CA数字证书的核心原理
看了蛋老师的视频就很容易理解了，首先对服务器的公钥和信息进行哈希运算得到一个短字符串，然后用CA机构中的私钥对这一短字符串进行加密就得到了一个数字签名，然后就这个数字签名放到数字证书中，同时服务器的公
阅读更多2024-09-21
git 操作远程别名
【代码】git 操作远程别名。
阅读更多2024-09-21

Qt/C++ 多线程同步机制详解及应用

1. 互斥锁（QMutex / std::mutex）

示例代码及注释

解释：

2. 信号量（QSemaphore）

示例代码及注释

解释：

3. 读写锁（QReadWriteLock）

示例代码及注释

解释：

4. 原子操作（QAtomicInt / std::atomic）

示例代码及注释

解释：

5. 条件变量（QWaitCondition / std::condition_variable）

示例代码及注释

解释：

相关文章

1. 互斥锁（`QMutex` / `std::mutex`）

2. 信号量（`QSemaphore`）

3. 读写锁（`QReadWriteLock`）

4. 原子操作（`QAtomicInt` / `std::atomic`）

5. 条件变量（`QWaitCondition` / `std::condition_variable`）