当前位置： 首页 > news >正文

C++并发编程-4.unique_lock,共享锁和递归锁

news 来源：原创 2025/6/28 9:32:52
  • 本文介绍C++ 并发中使用的其他类型的锁，包括unique_lock，shared_lock, 以及recursive_lock等。shared_lock和unique_lock比较常用，而recursive_lock用的不多，或尽可能规避用这种锁。

unique_lock

  • unique_lock和lock_guard基本用法相同，构造时默认加锁，析构时默认解锁，但unique_lock有个好处就是可以手动解锁。这一点尤为重要，方便我们控制锁住区域的粒度(加锁的范围大小),也能支持和条件变量配套使用，至于条件变量我们之后再介绍，本文主要介绍锁的相关操作。

#include<iostream>
#include<mutex>
#include<stack>
#include<memory>
#include<thread>
using std::cout;
using std::endl;//unique_lock   开始
std::mutex mtx;
int shared_data = 0;
void use_unique() {//lock可自动解锁，也可手动解锁std::unique_lock<std::mutex> lock(mtx);std::cout << "lock success" << std::endl;shared_data++;lock.unlock();
}// 我们可以通过unique_lock的owns_lock判断是否持有锁
//可判断是否占有锁
void owns_lock() {//lock可自动解锁，也可手动解锁std::unique_lock<std::mutex> lock(mtx);shared_data++;if (lock.owns_lock()) {std::cout << "owns lock" << std::endl;     // True}else {std::cout << "doesn't own lock" << std::endl;}lock.unlock();if (lock.owns_lock()) {std::cout << "owns lock" << std::endl;}else {std::cout << "doesn't own lock" << std::endl;  // True}
}//unique_lock可以延迟加锁
//可以延迟加锁
void defer_lock() {//延迟加锁std::unique_lock<std::mutex> lock(mtx, std::defer_lock);if (lock.owns_lock()) {std::cout << "owns lock" << std::endl;     // False}if (lock.owns_lock()) {std::cout << "owns lock" << std::endl;}else {std::cout << "doesn't own lock" << std::endl;  // True}//可以加锁lock.lock();//可以自动析构解锁，也可以手动解锁lock.unlock();
}//unique_lock   结束
int main()
{//use_unique();//owns_lock();defer_lock();return 0;
}
  • 整合运用
#include<iostream>
#include<mutex>
#include<stack>
#include<memory>
#include<thread>
using std::cout;
using std::endl;//unique_lock   开始
std::mutex mtx;
int shared_data = 0;
void use_unique() {//lock可自动解锁，也可手动解锁std::unique_lock<std::mutex> lock(mtx);std::cout << "lock success" << std::endl;shared_data++;lock.unlock();
}// 我们可以通过unique_lock的owns_lock判断是否持有锁
//可判断是否占有锁
void owns_lock() {//lock可自动解锁，也可手动解锁std::unique_lock<std::mutex> lock(mtx);shared_data++;if (lock.owns_lock()) {std::cout << "owns lock" << std::endl;     // True}else {std::cout << "doesn't own lock" << std::endl;}lock.unlock();if (lock.owns_lock()) {std::cout << "owns lock" << std::endl;}else {std::cout << "doesn't own lock" << std::endl;  // True}
}//unique_lock可以延迟加锁
//可以延迟加锁
void defer_lock() {//延迟加锁std::unique_lock<std::mutex> lock(mtx, std::defer_lock);if (lock.owns_lock()) {std::cout << "owns lock" << std::endl;     // False}if (lock.owns_lock()) {std::cout << "owns lock" << std::endl;}else {std::cout << "doesn't own lock" << std::endl;  // True}//可以加锁lock.lock();//可以自动析构解锁，也可以手动解锁lock.unlock();
}//同时使用owns和defer
void use_own_defer() {std::unique_lock<std::mutex>  lock(mtx);// 判断是否拥有锁if (lock.owns_lock()){std::cout << "Main thread has the lock." << std::endl; // True}else{std::cout << "Main thread does not have the lock." << std::endl;}std::thread t([]() {std::unique_lock<std::mutex> lock(mtx, std::defer_lock);// 判断是否拥有锁if (lock.owns_lock()){std::cout << "Thread has the lock." << std::endl;}else{std::cout << "Thread does not have the lock." << std::endl;// True}// 加锁lock.lock();// 判断是否拥有锁if (lock.owns_lock()){std::cout << "Thread has the lock." << std::endl; // // True}else{std::cout << "Thread does not have the lock." << std::endl;}// 解锁lock.unlock();});lock.unlock();t.join();
}
//unique_lock   结束
int main()
{//use_unique();//owns_lock();//defer_lock();use_own_defer();return 0;
}
  • 和lock_guard一样，unique_lock也支持领养锁

//同样支持领养操作
void use_own_adopt() {mtx.lock();std::unique_lock<std::mutex> lock(mtx, std::adopt_lock);if (lock.owns_lock()) {std::cout << "owns lock" << std::endl;}else {std::cout << "does not have the lock" << std::endl;}lock.unlock();
}
  • 尽管是领养的，但是打印还是会出现owns lock，因为不管如何锁被加上，就会输出owns lock。既然unique_lock支持领养操作也支持延迟加锁，那么可以用两种方式实现前文lock_guard实现的swap操作。

//之前的交换代码可以可以用如下方式等价实现
int a = 10;
int b = 99;
std::mutex  mtx1;
std::mutex  mtx2;
void safe_swap() {std::lock(mtx1, mtx2);std::unique_lock<std::mutex> lock1(mtx1, std::adopt_lock);std::unique_lock<std::mutex> lock2(mtx2, std::adopt_lock);std::swap(a, b);//错误用法//mtx1.unlock();//mtx2.unlock();
}
void safe_swap2() {std::unique_lock<std::mutex> lock1(mtx1, std::defer_lock);std::unique_lock<std::mutex> lock2(mtx2, std::defer_lock);//需用lock1,lock2加锁std::lock(lock1, lock2);//错误用法//std::lock(mtx1, mtx2);std::swap(a, b);
}
  • 大家注意一旦mutex被unique_lock管理，加锁和释放的操作就交给unique_lock，不能调用mutex加锁和解锁，因为锁的使用权已经交给unique_lock了。我们知道mutex是不支持移动和拷贝的，但是unique_lock支持移动，当一个mutex被转移给unique_lock后，可以通过unique_ptr转移其归属权.
    注意延迟加锁和领养锁之后，就只能使用后者进行解锁了，不能使用原生的锁进行解锁操作

/转移互斥量所有权
//互斥量本身不支持move操作，但是unique_lock支持
std::unique_lock <std::mutex>  get_lock() {std::unique_lock<std::mutex>  lock(mtx);shared_data++;return lock;
}
void use_return() {std::unique_lock<std::mutex> lock(get_lock());shared_data++;
}

锁的粒度表示加锁的精细程度，一个锁的粒度要足够大，保证可以锁住要访问的共享数据。同时一个锁的粒度要足够小，保证非共享数据不被锁住影响性能。而unique_ptr则很好的支持手动解锁。

void precision_lock() {std::unique_lock<std::mutex> lock(mtx);shared_data++;lock.unlock();//不设计共享数据的耗时操作不要放在锁内执行std::this_thread::sleep_for(std::chrono::seconds(1));lock.lock();shared_data++;
}

共享锁

  • 试想这样一个场景，对于一个DNS服务，我们可以根据域名查询服务对应的ip地址，它很久才更新一次，比如新增记录，删除记录或者更新记录等。平时大部分时间都是提供给外部查询，对于查询操作，即使多个线程并发查询不加锁也不会有问题，但是当有线程修改DNS服务的ip记录或者增减记录时，其他线程不能查询，需等待修改完再查询。或者等待查询完，线程才能修改。也就是说读操作并不是互斥的，同一时间可以有多个线程同时读，但是写和读是互斥的，写与写是互斥的，简而言之，写操作需要独占锁。而读操作需要共享锁。

  • 要想使用共享锁，需使用共享互斥量std::shared_mutex,std::shared_mutex是C++17标准提出的。C++14标准可以使用std::shared_time_mutex,

  • std::shared_mutex 和 std::shared_timed_mutex 都是用于实现多线程并发访问共享数据的互斥锁，但它们之间存在一些区别：

  • std::shared_mutex：

    • 提供了 lock(), try_lock(), 和 try_lock_for() 以及 try_lock_until() 函数，这些函数都可以用于获 取互斥锁。
    • 提供了 try_lock_shared() 和 lock_shared() 函数，这些函数可以用于获取共享锁。
    • 当 std::shared_mutex 被锁定后，其他尝试获取该锁的线程将会被阻塞，直到该锁被解锁。

  • std::shared_timed_mutex：

    • 与 std::shared_mutex 类似，也提供了 lock(), try_lock(), 和 try_lock_for() 以及 try_lock_until() 函数用于获取互斥锁。
    • 与 std::shared_mutex 不同的是，它还提供了 try_lock_shared() 和 lock_shared() 函数用于获取共享锁，这些函数在尝试获取共享锁时具有超时机制。
    • 当 std::shared_timed_mutex 被锁定后，其他尝试获取该锁的线程将会被阻塞，直到该锁被解锁，这与 std::shared_mutex 相同。然而，当尝试获取共享锁时，如果不能立即获得锁，std::shared_timed_mutex 会设置一个超时，超时过后如果仍然没有获取到锁，则操作将返回失败。

C++11标准没有共享互斥量，可以使用boost提供的boost::shared_mutex。如果我们想构造共享锁，可以使用std::shared_lock，如果我们想构造独占锁, 可以使用std::lock_gurad.我们用一个类DNService代表DNS服务，查询操作使用共享锁，而写操作使用独占锁，可以是如下方式的。

在这里插入图片描述


#include <iostream>
#include <memory>
#include<mutex>
#include<thread>
#include<map>
#include <shared_mutex> // std::shared_mutex(C++17引入)   std::shared_lock(C++14引入)
class DNService {
public:DNService() {}//读操作采用共享锁std::string QueryDNS(std::string dnsname) {std::shared_lock<std::shared_mutex> shared_locks(_shared_mtx);auto iter = _dns_info.find(dnsname);if (iter != _dns_info.end()) {return iter->second;}return "";}//写操作采用独占锁void AddDNSInfo(std::string dnsname, std::string dnsentry) {std::lock_guard<std::shared_mutex>  guard_locks(_shared_mtx);_dns_info.insert(std::make_pair(dnsname, dnsentry));}
private:std::map<std::string, std::string> _dns_info;mutable std::shared_mutex  _shared_mtx;
};

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

递归锁

有时候我们在实现接口的时候内部加锁，接口内部调用完结束自动解锁。会出现一个接口调用另一个接口的情况，如果用普通的std::mutex就会出现卡死，因为嵌套加锁导致卡死。


#include <iostream>
#include <mutex>
#include <thread>class BankAccount {
private:std::mutex mtx;double balance = 1000.0;public:// 接口1：存款void deposit(double amount) {std::lock_guard<std::mutex> lock(mtx);balance += amount;std::cout << "Deposited " << amount << ", new balance: " << balance << std::endl;}// 接口2：取款void withdraw(double amount) {std::lock_guard<std::mutex> lock(mtx);if (balance >= amount) {balance -= amount;std::cout << "Withdrew " << amount << ", new balance: " << balance << std::endl;} else {std::cout << "Insufficient funds for withdrawal of " << amount << std::endl;}}// 接口3：转账（会调用存款和取款接口）void transfer(BankAccount& toAccount, double amount) {std::lock_guard<std::mutex> lock(mtx);  // 第一次加锁this->withdraw(amount);  // 内部再次尝试加锁 - 这里会导致死锁!toAccount.deposit(amount);}
};int main() {BankAccount accountA;BankAccount accountB;// 这个调用会导致死锁accountA.transfer(accountB, 100.0);return 0;
}

在这里插入图片描述

但是我们可以使用递归锁。


#include <iostream>
#include <mutex>class BankAccount {
private:std::recursive_mutex mtx;  // 关键修改：使用可重入锁double balance = 1000.0;public:void deposit(double amount) {std::lock_guard<std::recursive_mutex> lock(mtx);balance += amount;std::cout << "Deposited " << amount << ", new balance: " << balance << std::endl;}void withdraw(double amount) {std::lock_guard<std::recursive_mutex> lock(mtx);if (balance >= amount) {balance -= amount;std::cout << "Withdrew " << amount << ", new balance: " << balance << std::endl;}else {std::cout << "Insufficient funds for withdrawal of " << amount << std::endl;}}void transfer(BankAccount& toAccount, double amount) {std::lock_guard<std::recursive_mutex> lock(mtx);  // 第一次加锁this->withdraw(amount);  // 内部再次加锁 - 现在可以正常工作toAccount.deposit(amount);}
};int main() {BankAccount accountA;BankAccount accountB;accountA.transfer(accountB, 100.0);return 0;
}

但我个人并不推荐递归锁，可以从设计源头规避嵌套加锁的情况，我们可以将接口相同的功能抽象出来，统一加锁。下面的设计演示了如何使用递归锁
//不推荐采用递归锁，使用递归锁说明设计思路并不理想，需优化设计
//推荐拆分逻辑，将共有逻辑拆分为统一接口

#include <iostream>
#include <mutex>class BankAccount {
private:std::mutex mtx;  // 使用普通互斥量double balance = 1000.0;// 不加锁的核心实现方法void unsafe_deposit(double amount) {balance += amount;std::cout << "Deposited " << amount << ", new balance: " << balance << std::endl;}// 不加锁的核心实现方法bool unsafe_withdraw(double amount) {if (balance >= amount) {balance -= amount;std::cout << "Withdrew " << amount << ", new balance: " << balance << std::endl;return true;}std::cout << "Insufficient funds for withdrawal of " << amount << std::endl;return false;}public:// 线程安全的公共接口void deposit(double amount) {std::lock_guard<std::mutex> lock(mtx);unsafe_deposit(amount);}void withdraw(double amount) {std::lock_guard<std::mutex> lock(mtx);unsafe_withdraw(amount);}void transfer(BankAccount& toAccount, double amount) {// 同时锁定两个账户，避免死锁std::unique_lock<std::mutex> lock1(mtx, std::defer_lock);std::unique_lock<std::mutex> lock2(toAccount.mtx, std::defer_lock);std::lock(lock1, lock2);  // 原子化加锁if (unsafe_withdraw(amount)) {toAccount.unsafe_deposit(amount);std::cout << "Transferred " << amount << " successfully" << std::endl;}}
};
int main() {BankAccount accountA;BankAccount accountB;// 这个调用会导致死锁accountA.transfer(accountB, 100.0);return 0;
}

在这里插入图片描述

相关文章：

  • 关于Kotlin与Java的思考
  • 通过ETL从MySQL同步到GaussDB
  • Linux工作常用命令记录
  • Android开发获取视图组件的findViewById，kotlin-android-extensions，ViewBinding三种详解
  • PyWavelets
  • 分布式系统ID生成方案深度解析：雪花算法 vs UUID vs 其他主流方案
  • 航天VR赋能，无人机总测实验舱开启高效新篇​
  • 鸿蒙OS开发IoT控制应用：从入门到实践
  • 基于JavaWeb的校园失物招领系统设计与实现
  • 机器学习2——贝叶斯理论下
  • 概述-2-MySQL安装及启动-1-Dcoker安装MySQL
  • 那些不应该的优化
  • Hall 定理 学习笔记
  • 【Redis】解码Redis中的list类型，基本命令，内部编码方式以及适用的场景
  • Ai大模型 - ocr图像识别形成结构化数据(pp-ocr+nlp结合) 以及训练微调实现方案(初稿)
  • Prompt Engineering For LLMs
  • 【Linux基础知识系列】第三十二篇 - Shell 历史与命令编辑
  • eSearch识屏 · 搜索 v15.0.1 官方版
  • 使用 Vcpkg 安装 Qt 时的常见问题与解决方法
  • 【论文阅读】Video-R1: Reinforcing Video Reasoning in MLLMs