深入理解C++中的锁

目录

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.mfbz.cn/a/766751.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

图解 Kafka 架构

图解 Kafka 架构

写在前面 Kafka 是一个可横向扩展&#xff0c;高可靠的实时消息中间件&#xff0c;常用于服务解耦、流量削峰。 好像是 LinkedIn 团队开发的&#xff0c;后面捐赠给apache基金会了。 kafka 总体架构图 Producer&#xff1a;生产者&#xff0c;消息的产生者&#xff0c;是消息的…
阅读更多...
android AIDL使用demo

android AIDL使用demo

背景 最近打算学习一下如何在framework层添加一个自定义service。 了解到自定义service需要使用aidl&#xff0c;为了加强对aidl的了解和使用过程&#xff0c;特意又温习了一下aidl的使用&#xff0c;并用博客的形式记录下来。 aidl官方参考&#xff1a;https://developer.and…
阅读更多...
不同系统间数据交换要通过 api 不能直接数据库访问

不同系统间数据交换要通过 api 不能直接数据库访问

很多大数据开发提供数据给外部系统直接给表结构&#xff0c;这是不好的方式。在不同系统间进行数据交换时&#xff0c;通过API&#xff08;应用程序编程接口&#xff09;而非直接访问数据库是现代系统集成的一种最佳实践。 目录 为什么要通过API进行数据交换如何通过API进行数据…
阅读更多...
论文辅导 | 基于多尺度分解的LSTM⁃ARIMA锂电池寿命预测

论文辅导 | 基于多尺度分解的LSTM⁃ARIMA锂电池寿命预测

辅导文章 模型描述 锂电池剩余使用寿命&#xff08;Remaining useful life&#xff0c;RUL&#xff09;预测是锂电池研究的一个重要方向&#xff0c;通过对RUL的准确预测&#xff0c;可以更好地管理和维护电池&#xff0c;延长电池使用寿命。为了能够准确预测锂电池的RUL&…
阅读更多...
STM32 看门狗 HAL

STM32 看门狗 HAL

由时钟图可以看出看门狗采用的是内部低速时钟&#xff0c;频率为40KHz 打开看门狗&#xff0c;采用32分频&#xff0c;计数1250。 结合设置的分频系数和重载计数值&#xff0c;我们可以计算出看门狗的定时时间&#xff1a; 32*1250/40kHz 1s 主函数中喂狗就行 HAL_IWDG_Ref…
阅读更多...
STM32 HAL库读取ID

STM32 HAL库读取ID

在stm32f1xx_hal.c文件中由读取ID号的子函数&#xff0c;不同单片机的UID_BASE不同&#xff0c;本单片机用的是STM32F103CBT6,跳转之后可以看到地址为&#xff1a;0x1FFFF7E8 在程序中只需定义一个数组调用读取ID的函数即可 uint32_t UID[3]; while(1) { UID[0] HAL_GetUIDw0…
阅读更多...
catia数控加工仿真铣平面粗加工

catia数控加工仿真铣平面粗加工

1&#xff0c;零件建模&#xff0c;毛坯建模 2 在毛坯上建立坐标系 3 添加资料刀具 4&#xff0c;双击对相关加工信息做设置 5 Roughing 加工设置 高亮红色区域是必选的&#xff0c;其他可以默认 6 完成加工仿真 7 加工余量
阅读更多...
EasyExcel4导入导出数据（基于MyBatisPlus）

EasyExcel4导入导出数据（基于MyBatisPlus）

一、POM依赖 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"><m…
阅读更多...
Camera Raw：编辑 - 细节

Camera Raw：编辑 - 细节

Camera Raw “编辑”模块中的细节 Detail面板用于增强照片的锐度和减少噪点。通过对锐化和降噪进行精细调整&#xff0c;可以提高图像的清晰度&#xff0c;减少噪点&#xff0c;提高图像质量。 ◆ ◆ ◆ 使用方法与技巧 1、增强照片锐度 较小的“半径”&#xff0c;较大的“细…
阅读更多...
如何解决大文件传输存在的痛点，实现高效流转？

如何解决大文件传输存在的痛点，实现高效流转？

在当代的数字化时代&#xff0c;数据资产在各行各业中扮演着举足轻重的角色&#xff0c;而数据的流通与交换则是其价值得以实现的关键。企业在进行大文件传输时&#xff0c;都面临着诸多挑战&#xff0c;比如网络延迟、大小受限、安全风险等。因此&#xff0c;如何高效安全的进…
阅读更多...
springboot个人证书管理系统16679

springboot个人证书管理系统16679

springboot个人证书管理系统 摘要 随着信息技术在管理上越来越深入而广泛的应用&#xff0c;管理信息系统的实施在技术上已逐步成熟。本文介绍了个人证书管理系统的开发全过程。通过分析个人证书管理系统管理的不足&#xff0c;创建了一个计算机管理个人证书管理系统的方案。文…
阅读更多...
3、FTL基本工作过程

3、FTL基本工作过程

上文描述了FTL的四大功能&#xff0c;这里简述一下每个功能的含义。 地址转换简述 FTL要维护一个地址转换表&#xff0c;这个转换表是主机读/写硬盘的逻辑地址到硬盘实际物理地址的转换关系。 假如SSD的容量是128G&#xff0c;SSD逻辑块的大小是4KB&#xff0c;那SSD的逻辑块…
阅读更多...
Linux系统的服务——以Centos7为例

Linux系统的服务——以Centos7为例

一、Linux系统的服务简介 服务是向外部提供对应功能的进程&#xff0c;其运行在系统后台&#xff0c;能够7*24小时持续不断的提供外界随时发来的服务请求&#xff0c;且服务进程常驻在内存中&#xff0c;具有固定的端口号&#xff0c;通过端口号就能找到服务内容。 提供服务的一…
阅读更多...
Linux源码阅读笔记10-进程NICE案例分析2

Linux源码阅读笔记10-进程NICE案例分析2

set_user_nice set_user_nice函数功能&#xff1a;设置某一进程的NICE值&#xff0c;其NICE值的计算是根据进程的静态优先级&#xff08;task_struct->static_prio&#xff09;&#xff0c;直接通过set_user_nice函数更改进程的静态优先级。 内核源码 void set_user_nice…
阅读更多...
Unity3d C#实现基于UGUI ScrollRect的轮播图效果功能(含源码)

Unity3d C#实现基于UGUI ScrollRect的轮播图效果功能(含源码)

前言 轮播功能是一种常见的页面组件&#xff0c;用于在页面中显示多张图片/素材并自动或手动进行切换&#xff0c;以提高页面的美观度和用户体验。主要的功能是&#xff1a;自动/手动切换;平滑的切换效果;导航指示器等。可惜Unity的UGUI系统里没有现成的实现该功能&#xff0c…
阅读更多...
BiTCN-Attention一键实现回归预测+8张图+特征可视化图！注意力全家桶再更新！

BiTCN-Attention一键实现回归预测+8张图+特征可视化图！注意力全家桶再更新！

声明&#xff1a;文章是从本人公众号中复制而来&#xff0c;因此&#xff0c;想最新最快了解各类智能优化算法及其改进的朋友&#xff0c;可关注我的公众号&#xff1a;强盛机器学习&#xff0c;不定期会有很多免费代码分享~ 目录 原理简介 数据介绍 结果展示 全家桶代码目…
阅读更多...
pom.xml文件加载后没有变成maven图标

pom.xml文件加载后没有变成maven图标

原因&#xff1a; 开启了IDEA的节电模式 现象为&#xff1a; xml会变橙色&#xff0c;yml变粉色&#xff0c;自动提示关闭等 把这个节能模式的勾选给取消掉就可以正常显示了
阅读更多...
flask的基本使用

flask的基本使用

1 sqlalchemy 快速使用 # 1 sqlalchemy 企业级orm框架# 2 python界的orm框架-1 django-orm #只能django框架用-2 peewee # 小型orm框架&#xff1a;https://docs.peewee-orm.com/en/latest/peewee/quickstart.html-----同步orm框架------3 sqlalchemy # 企业级…
阅读更多...
虚拟机交叉编译基于ARM平台的opencv(ffmpeg/x264)

虚拟机交叉编译基于ARM平台的opencv(ffmpeg/x264)

背景&#xff1a; 由于手上有一块rk3568的开发板&#xff0c;需要运行yolov5跑深度学习模型&#xff0c;但是原有的opencv不能对x264格式的视频进行解码&#xff0c;这里就需要将ffmpegx264编译进opencv。 但是开发板算力有限&#xff0c;所以这里采用在windows下&#xff0c;安…
阅读更多...
React Native V0.74 — 稳定版已发布

React Native V0.74 — 稳定版已发布

嗨，React Native开发者们， React Native 世界中令人兴奋的消息是，V0.74刚刚在几天前发布，有超过 1600 次提交。亮点如下： Yoga 3.0New Architecture: Bridgeless by DefaultNew Architecture: Batched onLayout UpdatesYarn 3 for New Projects让我们深入了解每一个新亮点…
阅读更多...
最新文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发 尧图建网站