多线程加锁的意义与死锁

最新推荐文章于 2024-04-12 00:09:12 发布
最新推荐文章于 2024-04-12 00:09:12 发布
阅读量544 收藏 4
点赞数 1
分类专栏： Qt 文章标签： qt c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_64113647/article/details/127025050
版权

基础知识

并发与并行

并发：单个CPU核心需要处理多个任务时会进行轮询，同一时刻只能处理一个任务。

并行：多个CPU核心同时处理任务，同一时刻能处理多个任务。

Image description

那么多线程编程是并发还是并行的呢？

我的理解是：在单核系统中，多线程是并发执行的；在多核系统中，多线程是并行执行的。

QtConcurrent::run的使用

在.pro文件中添加：QT += concurrent

QtConcurrent::run可以使用全局线程池和自定义线程池

// 全局线程池
template <typename T> QFuture<T> QtConcurrent::run(QThreadPool::globalInstance(), Function function, ...);
// 自定义线程池
template <typename T> QFuture<T> QtConcurrent::run(QThreadPool *pool, Function function, ...)

单线程与多线程程序的设计

调用简单的add()函数

#include <QCoreApplication>
#include <QDebug>

// add函数用于将count指向的内存自增1并打印出结果
void add(int *count) {
    *count = *count + 1;
    qDebug() << "thread id: " << QThread::currentThreadId() << "count: " << *count;
}

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

    int count = 0;
    for (int i=0; i<10; i++) {
        add(&count);
    }
    return a.exec();
}

无论如何执行，函数总是会按照顺序输出：1到10。此时输出的thread id为主线程id。

多线程中的的add()函数

#include <QCoreApplication>
#include <QDebug>
#include <QtConcurrent/QtConcurrent>
#include <QThreadPool>
#include <thread>

// add函数用于将count指向的内存自增1并打印出结果
void add(int *count) {
    *count = *count + 1;
    qDebug() << "thread id: " << QThread::currentThreadId() << "count: " << *count;
}

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    // 获取CPU核心数
    int numberOfCores = std::thread::hardware_concurrency();
    qDebug() << "Number of cores: " << numberOfCores;

    int count = 0;

    // 定义局部线程池变量
    QThreadPool pool;
    // 设置线程池最大使用的线程数量
    pool.setMaxThreadCount(numberOfCores * 2 + 1);
    for (int i=0; i<10; i++) {
        // 将函数放入线程池中运行
        QtConcurrent::run(&pool, add, &count);
    }

    return a.exec();
}

这是在我电脑中执行后的输出：

Image description

可以发现它并没有按照预期按照顺序输出：1到10。这里可以看到在输出相同数字时的thread id是不同的。造成这个的原因见下图：

Image description

线程0x1dac、0x2c98和0x4fb4在同一时刻同时执行了*count = *count + 1;，所以当执行到qDebug() << ......时，变量count已经被增加了3，所以会出现红色框中qDebug输出了3个相同的4，至于qDebug在何时输出就没那么重要了。

在多线程开发中，如果有一个变量对多线程是可见的，那么这个变量是非线程安全的。

加锁，使多线程按照预期输出（QMutex）

#include <QCoreApplication>
#include <QDebug>
#include <QtConcurrent/QtConcurrent>
#include <QThreadPool>
#include <thread>
#include <QMutex>

// add函数用于将count指向的内存自增1并打印出结果
void add(QMutex *mutex, int *count) {
    mutex->lock();
    *count = *count + 1;
    qDebug() << "thread id: " << QThread::currentThreadId() << "count: " << *count;
    mutex->unlock();
}

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    // 获取CPU核心数
    int numberOfCores = std::thread::hardware_concurrency();
    qDebug() << "Number of cores: " << numberOfCores;

    int count = 0;

    // 定义局部线程池变量
    QThreadPool pool;
    // 设置线程池最大使用的线程数量
    pool.setMaxThreadCount(numberOfCores * 2 + 1);
    // 定义锁变量
    QMutex mutex;
    for (int i=0; i<10; i++) {
        // 将函数放入线程池中运行
        QtConcurrent::run(&pool, add, &mutex, &count);
    }

    return a.exec();
}

无论运行多少次，函数总会预期的按照顺序输出：1到10。这是因为多线程共用了QMutex的锁对象，当一个线程执行方法QMutex::lock()后会占用当前锁对象，其他线程会等待该锁对象解锁QMutex::unlock()后才有资格去抢这把锁，只有抢到锁对象的才能够继续往下执行。所以执行的顺序如下图：

Image description

利用析构函数在函数退出时自动解锁（QMutexLocker）
#include <QCoreApplication>
#include <QDebug>
#include <QtConcurrent/QtConcurrent>
#include <QThreadPool>
#include <thread>
#include <QMutex>
#include <QMutexLocker>

// add函数用于将count指向的内存自增1并打印出结果
void add(QMutex *mutex, int *count) {
    QMutexLocker _(mutex);
    *count = *count + 1;
    qDebug() << "thread id: " << QThread::currentThreadId() << "count: " << *count;
}

......

死锁

怎样才能死锁？

以下死锁产生的四个必要条件：

  • 互斥条件：进程要求对所分配的资源进行排它性控制，即在一段时间内某资源仅为一进程所占用。
  • 请求和保持条件：当进程因请求资源而阻塞时，对已获得的资源保持不放。
  • 不剥夺条件：进程已获得的资源在未使用完之前，不能剥夺，只能在使用完时由自己释放。
  • 环路等待条件：若干进程行程形成循环等待资源关系。
测试死锁的代码：
#include <QCoreApplication>
#include <QDebug>
#include <QtConcurrent/QtConcurrent>
#include <QThreadPool>
#include <thread>
#include <QMutex>

// 定义f1函数
void f1(QMutex *m1, QMutex *m2) {
    m1->lock();
    qDebug() << "f1 thread id: " << QThread::currentThreadId() << "m1 lock";
    m2->lock();
    qDebug() << "f1 thread id: " << QThread::currentThreadId() << "m2 lock";
    m2->unlock();
    qDebug() << "f1 thread id: " << QThread::currentThreadId() << "m2 unlock";
    m1->unlock();
    qDebug() << "f1 thread id: " << QThread::currentThreadId() << "m1 unlock";
}

// 定义f2函数
void f2(QMutex *m1, QMutex *m2) {
    m2->lock();
    qDebug() << "f2 thread id: " << QThread::currentThreadId() << "m2 lock";
    m1->lock();
    qDebug() << "f2 thread id: " << QThread::currentThreadId() << "m1 lock";
    m1->unlock();
    qDebug() << "f2 thread id: " << QThread::currentThreadId() << "m1 unlock";
    m2->unlock();
    qDebug() << "f2 thread id: " << QThread::currentThreadId() << "m2 unlock";

}

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    // 获取CPU核心数
    int numberOfCores = std::thread::hardware_concurrency();
    qDebug() << "Number of cores: " << numberOfCores;

    // 定义局部线程池变量
    QThreadPool pool;
    // 设置线程池最大使用的线程数量
    pool.setMaxThreadCount(numberOfCores * 2 + 1);
    // 定义锁变量
    QMutex m1, m2;
    for (int i=0; i<100; i++) {
        // 将函数放入线程池中运行
        QtConcurrent::run(&pool, f1, &m1, &m2);
        QThread::sleep(1);
        QtConcurrent::run(&pool, f2, &m1, &m2);
    }

    return a.exec();
}

Image description

**当两个线程分别占有m2和m1时，死锁就这样发生了。**因为线程1占有了m1等待m2解锁后才能解锁m1而线程2占有了m2等待m1解锁后才能解锁m2，所以此时两个线程都被堵塞住无法继续正常执行了。

Image description

解决死锁

将等待资源的循环关系破坏掉，即可避免死锁了。将f2加锁顺序修改成先获得m1再获得m2，与f1的加锁顺序一致。

#include <QCoreApplication>
#include <QDebug>
#include <QtConcurrent/QtConcurrent>
#include <QThreadPool>
#include <thread>
#include <QMutex>

// 定义f1函数
void f1(QMutex *m1, QMutex *m2, int index) {
    m1->lock();
    qDebug() << "f1 thread id: " << QThread::currentThreadId() << "index: " << index << " m1 lock";
    m2->lock();
    qDebug() << "f1 thread id: " << QThread::currentThreadId() << "index: " << index << " m2 lock";
    m2->unlock();
    qDebug() << "f1 thread id: " << QThread::currentThreadId() << "index: " << index << " m2 unlock";
    m1->unlock();
    qDebug() << "f1 thread id: " << QThread::currentThreadId() << "index: " << index << " m1 unlock";
}

// 定义f2函数
void f2(QMutex *m1, QMutex *m2, int index) {
    m1->lock();
    qDebug() << "f1 thread id: " << QThread::currentThreadId() << "index: " << index  << " m1 lock";
    m2->lock();
    qDebug() << "f1 thread id: " << QThread::currentThreadId() << "index: " << index << " m2 lock";
    m2->unlock();
    qDebug() << "f1 thread id: " << QThread::currentThreadId() << "index: " << index << " m2 unlock";
    m1->unlock();
    qDebug() << "f1 thread id: " << QThread::currentThreadId() << "index: " << index << " m1 unlock";
}

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    // 获取CPU核心数
    int numberOfCores = std::thread::hardware_concurrency();
    qDebug() << "Number of cores: " << numberOfCores;

    // 定义局部线程池变量
    QThreadPool pool;
    // 设置线程池最大使用的线程数量
    pool.setMaxThreadCount(numberOfCores * 2 + 1);
    // 定义锁变量
    QMutex m1, m2;
    for (int i=0; i<10; i++) {
        // 将函数放入线程池中运行
        QtConcurrent::run(&pool, f1, &m1, &m2, i);
        QThread::sleep(1);
        QtConcurrent::run(&pool, f2, &m1, &m2, i);
    }

    return a.exec();
}

当线程1占有m1时，线程2等待m1解锁**（此时线程2无法占用m2锁）**，这时候线程1继续占有m2，然后解锁m2和m1，当m1解锁后线程2才能继续执行，所以不会产生死锁。

Image description

Fake瑞克
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Qt 多线程同步之互斥锁
希望能帮助大家，希望大家多多支持，你们的支持是我前进的动力。
03-15 1561
生产者-消费者模型 1.QMutex QMutex需要配对使用lock()和unlock()来实现代码段的保护 #ifndef MYTHREAD_H #define MYTHREAD_H #include <QThread> #include <QQueue> #include <QMutex> #include <QDebug> static int data = 100; static QQueue<int> que; stat
windowsC++多线程加锁信号量共享内存
07-07
在这个场景下，"windowsC++多线程加锁信号量共享内存"就是我们要探讨的核心主题。 首先，让我们了解什么是多线程。多线程是指一个进程中可以同时执行多个独立的执行流，每个流被称为一个线程。在C++中，可以通过`...
线程锁
gm0012的博客
11-02 145
什么是线程锁机制？ 多线程可以同时运行多个任务但是当多个线程同时访问共享数据时，可能导致数据不同步，甚至错误！ 　　so,不使用线程锁, 可能导致错误 　　在分布式集群系统的开发中，线程锁往往并不能支持全部场景的使用，必须引入新的技术方案分布式锁。 线程锁:大家都不陌生，主要用来给方法、代码块加锁。当某个方法或者代码块使用锁时，那么在同一时刻至多仅有有一个线程在执行该段代码。当有多个线程访问同一对象的加锁方法/代码块时，同一时间只有一个线程在执行，其余线程必须要等待当前线程执行完之后才能执行该代码段。但是，
通过8种加锁情况来弄懂加锁对于线程执行顺序的影响
最新发布
qq_65568592的博客
04-12 1070
非静态同步方法使用的锁对象是this，也就是方法的调用者，而本案例中使用的是两个不同的资源类对象分别创建的线程，所以两个同步方法使用的锁对象是不一样的，第一个线程使用的锁对象是example1，第二个使用的是example2；上面的案例中谈到加锁并不能防止不需要锁或者需要其他锁的线程，所以虽然线程1先抢到了锁，但是在休眠的3s内CPU是线程2的，并且线程2需要获取的是另一把锁，这就使得线程2会比线程1先执行完。既然锁对象是同一个，并且线程1先抢到锁，那必然是线程1先执行，线程2后执行了。
多线程为什么要使用锁？多线程如何保证线程安全？
ke1ying的博客
11-06 4434
多线程保证线程安全就是让多个线程执行的情况和单线程一样，读的时候是不影响线程安全的，但如果对数据操作，增加或者删除，几个线程同时进行，就会发生删多或者增加多的情况，这时候为了保证线程安全，就可以加对象锁。 并发不是很高的情况下，sychronized性能更好，优先选择，反之reentrantlock在高并发的情况下，性能会提高几十倍。或者使用reentrantlock三个独有的功能就选择reentrantlock： 两者都是可重入锁：都是同一个线程进入会+1，直到为0才释放锁， 两者.....
基于多线程并发-多线程为什么要加锁
qq_43148810的博客
01-31 2075
多线程为什么要加锁 1、数据竞争（data race） 1）多个线程访问其共有的资源（堆、全局变量等），需要加锁（互斥锁、读写锁、递归锁等），否则可能存在寄存器和内存数据不一致。 **注意：**堆对象的创建分为分配内存、初始化、指针指向该内存，注意锁的细粒度。 2）线程私有资源无需加锁。 2、不同线程的子步骤有顺序关联性 即线程2中必须等线程1将变量a赋值为1才能对a做除法。 注意: 为条件变量(std::condition_variable)的使用场景。 2）代码顺序不等同程序执行顺序
Java多线程——加锁机制
Allen的专栏
03-08 3373
Java的锁分为内置锁和显式锁。内置锁在我们平时使用synchronized关键字的时候获取。显式锁则是通过获取java.util.concurrent.locks包下面的ReentrantLock类或者ReentrantReadWriteLock类的实例来获取的。
对Python多线程读写文件加锁的实例详解
09-19
以下是对Python多线程读写文件加锁的详细解释。 首先，我们来看如何使用`fcntl`模块实现文件锁。`fcntl`模块提供了Unix系统中的`fcntl()`和`ioctl()`接口，其中`fcntl.flock()`函数是实现文件锁的关键。这个函数...
Java多线程产生死锁的必要条件
08-26
Java多线程产生死锁的必要条件 在 Java 多线程编程中，死锁是一个非常重要的概念。死锁是指两个或多个线程互相持有对方所需要的资源，导致这些线程处于等待状态，无法前往执行。在今天的文章中，我们将探讨 Java 多...
Java多线程之死锁的出现和解决方法
08-29
Java多线程之死锁的出现和解决方法 死锁是指多个线程同时被阻塞，它们中的一个或者全部都在等待某个资源被释放。由于线程被无限期地阻塞，因此程序不能正常运行。死锁的出现是由于不适当地运用“synchronized”...
浅谈python锁与死锁问题
12-17
加锁的原因 我们明白了锁的原理，不禁有了一个问题，我们为什么需要锁呢，它在哪些场景当中会用到呢？ 其实它的使用场景非常广，我们举一个非常简单的例子，就是淘宝买东西。我们都知道商家的库存都是有限的，卖掉一...
Qt两种方法实现多线程并安全结束线程及QMutex加锁Qt单例化实现
11-07
Qt两种方法实现多线程的开启，及子线程的安全结束线程，及QMutex加锁，Qt单例化实现
线程锁是什么？
Blue92120的博客
10-19 250
线程锁（也称为互斥锁）是一种同步机制，用于保护共享资源或临界区，以防止多个线程同时访问或修改数据。线程锁实际上是锁住的是共享资源，而不是线程本身。当多个线程需要访问或修改共享资源时，线程锁可以确保只有一个线程可以进入临界区，其他线程需要等待。这样可以避免多个线程同时对共享资源进行读写操作，导致数据不一致或竞态条件的问题。线程锁的基本原理是，在进入临界区之前，线程会尝试获取锁。如果锁已经被其他线程占用，则当前线程会被阻塞，直到锁被释放。一旦线程成功获取到锁，它就可以进入临界区，执行对共享资源的操作。
实现线程同步之线程锁以及理解
qq_43279936的博客
02-23 1293
线程锁的作用： 当多个线程同时进行任务时，为保证不会有多个线程对同一个数据进行操作造成不可预料的后果，加个锁，将此时的线 程变为单线程进行操作。 当多个线程同时执行lock.acquire时，只有一个线程能成功地获取锁，然后继续执行代码，其他线程就继续等待直到获得 锁为止。 获得锁的线程用完后一定要释放锁，否则那些苦苦等待锁的线程将永远等待下去，成为死线程。 线程锁...
线程之间的通信、加锁解锁
今夕莫离-IT
10-09 528
#import "ViewController.h" @interface ViewController () //NSLock //既可以对基本数据类型的数据加锁，也可以对对象加锁，是万能的 @property(nonatomic,strong) NSLock *lock; @end @implementation ViewController //服务
谈谈多线程下为何需要锁
热门推荐
guojunfenglinux的博客
08-20 1万+
什么是锁？为什么存在？ 多个线程运行的时候，共享了同一块资源，在访问这块资源的时候就称为临界资源。为了解决这个问题，我们可以为这块资源加上一把锁,只允许一个线程访问这块资源。 那今天就讲讲互斥锁，自旋锁。 首先先看看不加锁的情况下多线程共享访问临界资源会发生什么. 代码很简单，开启10个线程，各加上100000，理想结果应该是10 * 100000，好的，来试试吧 ```c #include <stdio.h> #include <pthread.h> #define THREA
线程加锁过程-锁升级
重点在于记录
04-01 454
都说synchronized锁jdk1.6之前很慢，1.6以后优化的已经很快了，今天看一下到底怎么个快法了，优化了哪些呢？ 大概意思就是jdk1.6以前加锁就是重量级锁之后又引入了偏向锁、轻量级锁，从而总共有了四种锁状态，由低到高为：无锁状态-》偏向锁状态-》轻量级锁状态-》重量级锁状态 1、无锁状态 没有对资源进行锁定，所有线程都能访问公共资源 2、偏向锁 一段同步代码块，不存在多线程...
Qt 多线程 互斥锁使用小结
FJE924949251的博客
05-21 724
Qt 多线程使用，互斥量使用
性能测试面试题：多线程高并发场景下，为什么需要加锁？
qq13536605264的博客
04-06 705
确保线程安全是性能测试高并发多线程测试中必不可少的一个重要步骤，采用适当的加锁措施可以避免线程间数据竞争的问题，确保测试的可靠性和准确性
多线程加锁需要注意什么
07-27
多线程加锁是为了保证多个线程对共享资源的访问安全性。在使用多线程加锁时，需要注意以下几点： ...总之，多线程加锁需要综合考虑性能、正确性、一致性和并发度等因素，合理选择加锁的粒度，并避免死锁的发生。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值