深入理解C++中的锁

news2024/10/6 6:52:16

目录

1.基本互斥锁（std::mutex）

2.递归互斥锁（std::recursive_mutex）

3.带超时机制的互斥锁（std::timed_mutex）

4.带超时机制的递归互斥锁（std::recursive_timed_mutex）

5.共享互斥锁也叫读写锁（std::shared_mutex）

6.带超时机制的共享互斥锁（std::shared_timed_mutex）

7.自旋锁

8.总结

1.基本互斥锁（std::mutex）

含义: std::mutex是最基本的互斥锁，主要用于保护临界区，确保同一时间只有一个线程可以访问共享资源。

使用场景: 当需要保护共享资源不被多个线程同时修改时使用。

特点：简单易用，适用于大多数场景；不能递归锁定，同一线程多次尝试锁定会导致死锁。

以下是一个简单的示例，展示了如何使用 std::mutex 来保护共享数据：

#include <iostream>  
#include <thread>  
#include <mutex>  
  
std::mutex mtx;     //全局互斥锁
int shared_data = 0;   //共享数据
  
void increment_shared_data(int n) {  
    for (int i = 0; i < n; ++i) {  
        std::lock_guard<std::mutex> lock(mtx);  
        ++shared_data;  
    }  
}  
  
int main() {  
    std::thread t1(increment_shared_data, 1000);  
    std::thread t2(increment_shared_data, 1000);  
  
    t1.join();  
    t2.join();  
  
    std::cout << "Shared data: " << shared_data << std::endl;  
    return 0;  
}

 这个程序创建了2个线程，每个线程尝试对counter增加10000次。通过使用std::mutex, 我们确保每次只有一个线程可以增加计数器，避免了数据竞争。

2.递归互斥锁（std::recursive_mutex）

含义：std::recursive_mutex允许同一线程多次获取锁而不会发生死锁，这对于递归函数或需要多次锁定的场景非常有用。

使用场景: 在递归函数中需要多次获取同一个锁的情况。

特点：适用于递归调用和需要多次锁定的场景；需要注意避免滥用，因为递归锁的使用会增加锁定次数的复杂性。

示例如下：

#include <iostream>
#include <thread>
#include <mutex>

std::recursive_mutex rmtx;

void recursive_function(int depth) {
    rmtx.lock();
    std::cout << "Depth: " << depth << std::endl;
    if (depth > 0) {
        recursive_function(depth - 1);
    }
    rmtx.unlock();
}

int main() {
    std::thread t(recursive_function, 5);
    t.join();

    return 0;
}

这段代码在递归函数recursive_function中使用std::recursive_mutex。每次调用都会尝试加锁，由于使用的是递归互斥锁，同一线程可以多次成功获取锁。

3.带超时机制的互斥锁（std::timed_mutex）

含义：std::timed_mutex在std::mutex的基础上增加了超时功能，允许线程在指定时间内尝试获取锁，如果在超时时间内未成功获取锁，则返回失败。

使用场景: 当你不希望线程因等待锁而无限期阻塞时使用。

特点：适用于需要设置锁获取超时时间的场景；提供try_lock_for和try_lock_until两种超时尝试获取锁的方法。

示例如下：

#include <iostream>  
#include <thread>  
#include <mutex>  
#include <chrono>  
  
std::timed_mutex mtx;  
  
void try_lock_function() {  
    if (mtx.try_lock_for(std::chrono::seconds(1))) {  
        std::cout << "Lock acquired!\n";  
        // 执行受保护的操作  
        std::this_thread::sleep_for(std::chrono::seconds(2)); // 模拟耗时操作  
        mtx.unlock(); // 显式解锁  
    } else {  
        std::cout << "Failed to acquire lock within timeout.\n";  
    }  
}  
  
int main() {  
    std::thread t1(try_lock_function);  
    std::thread t2(try_lock_function);  
  
    t1.join();  
    t2.join();  
  
    return 0;  
}

在这个例子中，两个线程都尝试在 1 秒内获取锁。由于互斥锁在同一时刻只能被一个线程持有，因此至少有一个线程将无法在超时时间内获取锁，并输出相应的消息。

4.带超时机制的递归互斥锁（std::recursive_timed_mutex）

含义：std::recursive_timed_mutex结合了std::recursive_mutex和std::timed_mutex的特性，支持递归锁定和超时机制。

使用场景: 适用于需要递归锁定资源，并且希望能够设置尝试获取锁的超时时间的场景。这在需要防止线程在等待锁时无限阻塞的复杂递归调用中特别有用。

特点：适用于递归调用和需要超时机制的场景；提供超时尝试获取递归锁的方法。

示例如下：

#include <iostream>  
#include <thread>  
#include <mutex>  
#include <chrono>  
  
std::recursive_timed_mutex mtx;  
  
void recursive_lock_function() {  
    if (mtx.try_lock_for(std::chrono::seconds(1))) {  
        std::cout << "Lock acquired!\n";  
          
        // 递归锁定  
        if (mtx.try_lock_for(std::chrono::seconds(1))) {  
            std::cout << "Recursive lock acquired!\n";  
            mtx.unlock(); // 释放递归锁  
        } else {  
            std::cout << "Failed to acquire recursive lock within timeout.\n";  
        }  
  
        // ... 执行受保护的操作  
  
        mtx.unlock(); // 释放原始锁  
    } else {  
        std::cout << "Failed to acquire lock within timeout.\n";  
    }  
}  
  
int main() {  
    std::thread t1(recursive_lock_function);  
    std::thread t2(recursive_lock_function);  
  
    t1.join();  
    t2.join();  
  
    return 0;  
}

请注意，由于 std::recursive_timed_mutex 允许递归锁定，上面的示例中展示了如何在已经持有锁的情况下再次尝试获取锁（尽管在这个特定示例中，第二次尝试获取锁是多余的，因为我们已经持有锁了）。然而，在实际情况中，递归锁定可能用于更复杂的场景，其中函数可能会递归调用自己，并且每个递归调用都需要访问受保护的数据。

5.共享互斥锁也叫读写锁（std::shared_mutex）

含义：std::shared_mutex允许多个线程同时读取，但只有一个线程可以写入。这在读多写少的场景下非常有用。

使用场景: 适用于读操作远多于写操作的情况。

特点：适用于读多写少的场景；读操作和写操作使用不同的锁定机制。

示例如下：


#include <iostream>
#include <thread>
#include <shared_mutex>

std::shared_mutex shmtx;

void read_shared(int id) {
    std::shared_lock<std::shared_mutex> lock(shmtx); // 共享锁
    std::cout << "Thread " << id << " is reading" << std::endl;
    std::this_thread::sleep_for(std::chrono::milliseconds(100));
}

void write_shared(int id) {
    std::unique_lock<std::shared_mutex> lock(shmtx); // 独占锁
    std::cout << "Thread " << id << " is writing" << std::endl;
    std::this_thread::sleep_for(std::chrono::milliseconds(100));
}

int main() {
    std::thread readers[5], writer(write_shared, 1);

    for (int i = 0; i < 5; ++i) {
        readers[i] = std::thread(read_shared, i + 2);
    }

    writer.join();
    for (auto& reader : readers) {
        reader.join();
    }

    return 0;
}

输出结果可能会有所不同，因为读写顺序由操作系统的线程调度决定。本例中，一个写线程在修改数据，多个读线程在同时读数据。通过std::shared_mutex，我们允许多个读操作同时进行，但写操作是独占的。

6.带超时机制的共享互斥锁（std::shared_timed_mutex）

含义：std::shared_timed_mutex 是 C++ 标准库中的一个同步原语，它结合了 std::shared_mutex（共享互斥锁）和超时机制的特性。std::shared_mutex 允许多个线程同时以共享模式持有锁（即读取操作可以并发执行），但每次只有一个线程能以独占模式持有锁（即写入操作是互斥的）。通过添加超时机制，std::shared_timed_mutex 允许线程尝试以共享模式或独占模式获取锁，并设置一个超时时间，如果在这段时间内未能成功获取锁，则可以放弃并继续执行其他操作。

使用场景：当你不希望线程因等待锁而无限期阻塞时使用。

特点：适用于读多写少且需要超时机制的场景；提供超时尝试获取共享锁的方法。

示例如下：

#include <iostream>
#include <thread>
#include <shared_mutex>
#include <chrono>

std::shared_timed_mutex shtmmtx;

void try_read_shared(int id) {
    if (shtmmtx.try_lock_shared_for(std::chrono::milliseconds(100))) {
        std::cout << "Thread " << id << " is reading" << std::endl;
        std::this_thread::sleep_for(std::chrono::milliseconds(50));
        shtmmtx.unlock_shared();
    } else {
        std::cout << "Thread " << id << " could not read" << std::endl;
    }
}

void try_write_shared(int id) {
    if (shtmmtx.try_lock_for(std::chrono::milliseconds(100))) {
        std::cout << "Thread " << id << " is writing" << std::endl;
        std::this_thread::sleep_for(std::chrono::milliseconds(50));
        shtmmtx.unlock();
    } else {
        std::cout << "Thread " << id << " could not write" << std::endl;
    }
}

int main() {
    std::thread readers[5], writer(try_write_shared, 1);

    for (int i = 0; i < 5; ++i) {
        readers[i] = std::thread(try_read_shared, i + 2);
    }

    writer.join();
    for (auto& reader : readers) {
        reader.join();
    }

    return 0;
}

7.自旋锁

含义：在C++中，自旋锁（spinlock）是一种低级的同步机制，用于保护共享资源，防止多个线程同时访问。与互斥锁（mutex）不同，当自旋锁被锁定时，尝试获取锁的线程会不断循环检查锁是否可用，而不是进入睡眠状态等待锁被释放。这意味着，自旋锁在等待时间很短的情况下是非常有效的，但如果等待时间过长，会导致CPU资源的浪费。

C++标准库本身并不直接提供自旋锁的实现，但你可以使用<atomic>库中的原子操作来手动实现一个自旋锁，或者使用特定平台提供的API（如Windows的SRWLOCK或POSIX的pthread_spinlock_t）。

使用场景：自旋锁适用于锁持有时间非常短且线程不希望在操作系统调度中频繁上下文切换的场景。这通常用在低延迟系统中，或者当线程数量不多于CPU核心数量时，确保CPU不会在等待锁时空闲。

示例如下：

#include <atomic>  
#include <iostream>  
#include <thread>  
#include <chrono>  
  
class Spinlock {  
private:  
    std::atomic_flag lock_ = ATOMIC_FLAG_INIT;  
  
public:  
    void lock() {  
        while (lock_.test_and_set(std::memory_order_acquire)) {  
            // 循环直到锁被释放  
        }  
    }  
  
    void unlock() {  
        lock_.clear(std::memory_order_release);  
    }  
  
    bool try_lock() {  
        return !lock_.test_and_set(std::memory_order_acquire);  
    }  
};  
  
void threadFunction(Spinlock& lock, int id) {  
    lock.lock();  
    std::cout << "Thread " << id << " entered critical section\n";  
    std::this_thread::sleep_for(std::chrono::milliseconds(100)); // 模拟耗时操作  
    std::cout << "Thread " << id << " leaving critical section\n";  
    lock.unlock();  
}  
  
int main() {  
    Spinlock lock;  
    std::thread t1(threadFunction, std::ref(lock), 1);  
    std::thread t2(threadFunction, std::ref(lock), 2);  
  
    t1.join();  
    t2.join();  
  
    return 0;  
}

        在这个例子中，Spinlock 类使用了一个 std::atomic_flag 类型的成员变量 lock_ 来实现锁的功能。lock_ 的 test_and_set 方法会尝试将标志设置为 true 并返回之前的值。如果返回 false，表示锁之前未被锁定，当前线程成功获取锁；如果返回 true，表示锁已被其他线程持有，当前线程需要继续循环等待。

        请注意，自旋锁在多核处理器上且等待时间较短时通常表现良好，但在等待时间较长或锁竞争激烈时可能会导致性能问题。因此，在选择使用自旋锁时，需要根据具体的应用场景和性能要求做出合理的选择。

8.总结

        C++标准库提供了多种类型的互斥锁，每种锁都有其特定的用途和特点。选择合适的互斥锁类型可以有效提高程序的并发性能和安全性。

C++惯用法之RAII思想: 资源管理_raii 思想-CSDN博客

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1888136.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

2.2.4 C#中显示控件BDPictureBox 的实现----ROI交互

2.2.4 C#中显示控件BDPictureBox 的实现----ROI交互

2.2.4 C#中显示控件BDPictureBox 的实现----ROI交互 1 界面效果 在设定模式下&#xff0c;可以进行ROI 框的拖动&#xff0c;这里以Rect1举例说明 2 增加ROI类定义 /// <summary> /// ROI_single /// 用于描述图片感兴趣区域 /// type: 0:Rect1;1:Rect2;2:Circle ;3:…
阅读更多...
压缩pdf文件大小，压缩pdf文件大小软件哪个好

压缩pdf文件大小，压缩pdf文件大小软件哪个好

在数字化时代&#xff0c;PDF文件因其卓越的跨平台兼容性和稳定性而成为工作与学习的好帮手。然而&#xff0c;当PDF文件体积过大时&#xff0c;传输和存储便成了一项挑战。别担心&#xff0c;本文将为你揭秘如何快速压缩PDF文件&#xff0c;让你的文档轻装上路&#xff01; 压…
阅读更多...
【Python实战因果推断】14_线性回归的不合理效果4

【Python实战因果推断】14_线性回归的不合理效果4

目录 Debiasing Step Denoising Step Standard Error of the Regression Estimator Debiasing Step 回想一下&#xff0c;最初由于混杂偏差&#xff0c;您的数据看起来是这样的、 随着信贷额度的增加&#xff0c;违约率呈下降趋势&#xff1a; 根据 FWL 定理&#xff0c;您可…
阅读更多...
力扣习题--哈沙德数

力扣习题--哈沙德数

一、前言 本系列主要讲解和分析力扣习题&#xff0c;所以的习题均来自于力扣官网题库 - 力扣 (LeetCode) 全球极客挚爱的技术成长平台 二、哈沙德数 1. 哈沙德数 如果一个整数能够被其各个数位上的数字之和整除&#xff0c;则称之为 哈沙德数&#xff08;Harshad number&…
阅读更多...
JAVA学习笔记-JAVA基础语法-DAY21-缓冲流、转换流、序列化流

JAVA学习笔记-JAVA基础语法-DAY21-缓冲流、转换流、序列化流

第一章 缓冲流 昨天学习了基本的一些流&#xff0c;作为IO流的入门&#xff0c;今天我们要见识一些更强大的流。比如能够高效读写的缓冲流&#xff0c;能够转换编码的转换流&#xff0c;能够持久化存储对象的序列化流等等。这些功能更为强大的流&#xff0c;都是在基本的流对象…
阅读更多...
【echarts】拖拽滑块dataZoom-slider自定义样式，简单适配移动端

【echarts】拖拽滑块dataZoom-slider自定义样式，简单适配移动端

电脑端 移动端 代码片段 dataZoom: [{type: inside,start: 0,end: 100},{type: slider,backgroundColor: #F2F5F9,fillerColor: #BFCCE3,height: 13, // 设置slider的高度为15start: 0,end: 100,right: 60,left: 60,bottom: 15,handleIcon:path://M30.9,53.2C16.8,53.2,5.3,41.…
阅读更多...
【Git 学习笔记】1.3 Git 的三个阶段

【Git 学习笔记】1.3 Git 的三个阶段

1.3 Git 的三个阶段 由于远程代码库后续存在新的提交&#xff0c;因此实操过程中的结果与书中并不完全一致。根据书中 HEAD 指向的 SHA-1&#xff1a;34acc370b4d6ae53f051255680feaefaf7f7850d&#xff0c;可通过以下命令切换到对应版本&#xff0c;并新建一个 newdemo 分支来…
阅读更多...
基于LSTM、GRU和RNN的交通时间序列预测（Python）

基于LSTM、GRU和RNN的交通时间序列预测（Python）

近年来&#xff0c;人工智能技术的发展推动了智慧交通领域的进步&#xff0c;交通流预测日益成为研究热点之一。交通流预测是基于历史的交通数据对未来时段的交通流状态参数进行预测。作为交通流状态的直接反映&#xff0c;交通流参数的预测结果可以直接应用于 ATIS 和ATMS 中&…
阅读更多...
QT Designer中的qrc文件如何创建，将图片添加进qrc文件

QT Designer中的qrc文件如何创建，将图片添加进qrc文件

创建qrc文件可以在qt中给空间添加个性化属性 一、创建qrc文件的方式 1、将以下代码复制到txt文件文件中 <!DOCTYPE RCC> <RCC version"1.0"> <qresource prefix"/"><file>background_img.png</file><file>backgrou…
阅读更多...
第二证券：可转债基础知识？想玩可转债一定要搞懂的交易规则！

第二证券：可转债基础知识？想玩可转债一定要搞懂的交易规则！

可转债&#xff0c;全称是“可转化公司债券”&#xff0c;是上市公司为了融资&#xff0c;向社会公众所发行的一种债券&#xff0c;具有股票和债券的双重特点&#xff0c;投资者可以选择按照发行时约定的价格将债券转化成公司一般股票&#xff0c;也可作为债券持有到期后收取本…
阅读更多...
计算机网络网络层复习题1

计算机网络网络层复习题1

一. 单选题&#xff08;共27题&#xff09; 1. (单选题)以太网 MAC 地址、IPv4 地址、IPv6 地址的地址空间大小分别是&#xff08; &#xff09;。 A. 2^48&#xff0c;2^32&#xff0c;2^128B. 2^32&#xff0c;2^32&#xff0c;2^96C. 2^16&#xff0c;2^56&#xff0c;2^6…
阅读更多...
【51单片机入门】矩阵键盘

【51单片机入门】矩阵键盘

文章目录 前言矩阵键盘介绍与检测原理原理图代码讲解总结 前言 在嵌入式系统设计中&#xff0c;键盘输入是一种常见的人机交互方式。其中&#xff0c;矩阵键盘因其简单、方便和易于扩展的特性&#xff0c;被广泛应用于各种设备中。本文将介绍如何使用51单片机来实现矩阵键盘的…
阅读更多...
修改Springboot项目名称

修改Springboot项目名称

修改Springboot项目名称 1. 整体描述2. 具体步骤2.1 修改module名称2.2 修改程序包名2.3 mybatis/mybatis-plus配置修改2.4 logback文件2.5 yml配置2.6 Application启动类2.7 其他 3. 总结 1. 整体描述 开发过程中&#xff0c;经常遇到新来个项目&#xff0c;需要一份初始代码…
阅读更多...
数字化精益生产系统--RD研发管理系统

数字化精益生产系统--RD研发管理系统

R&D研发管理系统是一种用于管理和监督科学研究和技术开发的软件系统&#xff0c;其设计和应用旨在提高企业研发活动的效率、质量和速度。以下是对R&D研发管理系统的功能设计&#xff1a;
阅读更多...
学习springMVC

学习springMVC

第四章 Spring MVC 第一节 Spring MVC 简介 1. Spring MVC SpringMVC是一个Java 开源框架&#xff0c; 是Spring Framework生态中的一个独立模块&#xff0c;它基于 Spring 实现了Web MVC&#xff08;数据、业务与展现&#xff09;设计模式的请求驱动类型的轻量级Web框架&am…
阅读更多...
和鲸“101”计划领航！和鲸科技携手北中医，共话医学+AI 实验室建设及创新人才培养

和鲸“101”计划领航！和鲸科技携手北中医，共话医学+AI 实验室建设及创新人才培养

为进一步加强医学院校大数据管理与应用、信息管理与信息系统&#xff0c;医学信息工程等专业建设&#xff0c;交流实验室建设、专业发展与人才培养经验&#xff0c;6 月 22 日&#xff0c;由北京中医药大学&#xff08;简称“北中医”&#xff09;主办&#xff0c;上海和今信息…
阅读更多...
使用Spring Boot实现博客管理系统

使用Spring Boot实现博客管理系统

文章目录 引言第一章 Spring Boot概述1.1 什么是Spring Boot1.2 Spring Boot的主要特性 第二章 项目初始化第三章 用户管理模块3.1 创建用户实体类3.2 创建用户Repository接口3.3 实现用户Service类3.4 创建用户Controller类 第四章 博客文章管理模块4.1 创建博客文章实体类4.2…
阅读更多...
to_json 出现乱码的解决方案

to_json 出现乱码的解决方案

大家好，我是爱编程的喵喵。双985硕士毕业，现担任全栈工程师一职，热衷于将数据思维应用到工作与生活中。从事机器学习以及相关的前后端开发工作。曾在阿里云、科大讯飞、CCF等比赛获得多次Top名次。现为CSDN博客专家、人工智能领域优质创作者。喜欢通过博客创作的方式对所学的…
阅读更多...
PyCharm远程开发

PyCharm远程开发

PyCharm远程开发 1- 远程环境说明 每个人的本地电脑环境差别很大。各自在自己电脑上开发功能&#xff0c;测试/运行正常。但是将多个人的代码功能合并&#xff0c;运行服务器上&#xff0c;会出现各种版本兼容性问题。 在实际企业中&#xff0c;一般会有两套环境。第一套是测…
阅读更多...
2.3 主程序和外部IO交互 （文件映射方式）----IO Server实现

2.3 主程序和外部IO交互 （文件映射方式）----IO Server实现

2.3 主程序和外部IO交互 &#xff08;文件映射方式&#xff09;----IO Server C实现 效果显示 1 内存共享概念 基本原理&#xff1a;以页面为单位&#xff0c;将一个普通文件映射到内存中&#xff0c;达到共享内存和节约内存的目的&#xff0c;通常在需要对文件进行频繁读写时…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023