c++,mutex,unique_lock,recursive_mutex,shared_mutex对比分析
当处理多线程并发时,正确使用锁是确保线程安全的关键。
1. std::mutex(互斥锁):
std::mutex
是C++标准库提供的最基本的锁。它的基本使用如下:
#include <iostream>
#include <mutex>
#include <thread>
std::mutex myMutex;
void sharedResourceAccess() {
std::lock_guard<std::mutex> lock(myMutex);
// 访问共享资源的代码
std::cout << "Accessing shared resource...\n";
}
int main() {
std::thread t1(sharedResourceAccess);
std::thread t2(sharedResourceAccess);
t1.join();
t2.join();
return 0;
}
注意事项:
- 使用
std::lock_guard
是一种简单而安全的方式,它会在作用域结束时自动释放锁。 - 避免手动调用
unlock()
,因为忘记释放锁可能导致严重的问题。
2. std::unique_lock:
std::unique_lock
提供了更灵活的锁定和解锁方式,同时支持条件变量。在某些情况下,这种灵活性是很有用的:
#include <iostream>
#include <mutex>
#include <thread>
std::mutex myMutex;
void sharedResourceAccess() {
std::unique_lock<std::mutex> lock(myMutex);
// 访问共享资源的代码
std::cout << "Accessing shared resource...\n";
// lock.unlock(); // 可以手动解锁
}
int main() {
std::thread t1(sharedResourceAccess);
std::thread t2(sharedResourceAccess);
t1.join();
t2.join();
return 0;
}
注意事项:
std::unique_lock
可以在构造时不锁定,也可以手动解锁。- 支持条件变量,可以灵活地等待某个条件成立后再继续执行。
3. std::recursive_mutex:
std::recursive_mutex
允许同一个线程多次锁定同一把锁。这对于递归函数可能需要在同一线程中多次获取锁的情况很有用:
#include <iostream>
#include <mutex>
#include <thread>
std::recursive_mutex myRecursiveMutex;
void recursiveAccess(int depth) {
std::unique_lock<std::recursive_mutex> lock(myRecursiveMutex);
if (depth > 0) {
recursiveAccess(depth - 1);
}
// 访问共享资源的代码
std::cout << "Accessing shared resource at depth " << depth << "...\n";
}
int main() {
std::thread t1(recursiveAccess, 3);
t1.join();
return 0;
}
注意事项:
- 递归锁允许同一线程多次获取锁,但要小心不要导致死锁。
4. std::shared_mutex:
std::shared_mutex
是C++14标准引入的互斥锁,它提供了共享/独占两种锁定方式。这使得多个线程可以同时共享资源,而只有一个线程可以独占地修改资源。这在某些情况下能够提高并发性能。
以下是 std::shared_mutex
的主要特点和用法:
-
共享锁(Shared Lock):
- 多个线程可以同时获得共享锁,这允许它们并发地读取共享资源。
- 共享锁使用
std::shared_lock
来获取。
#include <shared_mutex> std::shared_mutex mySharedMutex; void readOperation() { std::shared_lock<std::shared_mutex> lock(mySharedMutex); // 读取共享资源的代码 }
-
独占锁(Exclusive Lock):
- 只有一个线程可以获得独占锁,这使得它能够独占地修改共享资源。
- 独占锁使用
std::unique_lock
来获取。
#include <shared_mutex> std::shared_mutex mySharedMutex; void writeOperation() { std::unique_lock<std::shared_mutex> lock(mySharedMutex); // 修改共享资源的代码 }
-
避免写者饥饿(Writer Starvation Avoidance):
std::shared_mutex
的设计旨在避免写者饥饿问题,即允许读者和写者以公平的方式争夺锁。
-
适用于读多写少的场景:
std::shared_mutex
在读多写少的情况下表现得较为优越,因为多个线程可以同时获得共享锁,提高了并发性能。
-
注意事项:
- 使用
std::shared_lock
进行读取操作,使用std::unique_lock
进行写入操作。 - 避免在写入操作中使用共享锁,以免破坏写者的互斥性。
- 使用
#include <iostream>
#include <shared_mutex>
#include <vector>
#include <thread>
int sharedData=0;
std::shared_mutex mySharedMutex;
void readOperation(int id) {
//std::shared_lock<std::shared_mutex> lock(mySharedMutex);
mySharedMutex.lock_shared();//手动控制
// 读取共享资源的代码
std::cout << "Reader " << id << " reading data: " << sharedData << std::endl;
mySharedMutex.unlock_shared();//手动控制
}
void writeOperation(int id) {
//std::unique_lock<std::shared_mutex> lock(mySharedMutex);
mySharedMutex.lock();//手动控制
// 修改共享资源的代码
sharedData=id;
std::cout << "Writer " << id << " writing data." << std::endl;
mySharedMutex.unlock();//手动控制
}
int main() {
std::vector<std::thread> readers;
std::vector<std::thread> writers;
for (int i = 0; i < 5; ++i) {
readers.emplace_back(readOperation, i);
writers.emplace_back(writeOperation, i);
}
for (auto& reader : readers) {
reader.join();
}
for (auto& writer : writers) {
writer.join();
}
return 0;
}
在这个示例中,读者和写者线程通过 std::shared_mutex
来协调对 sharedData
的读写操作。读者线程使用 std::shared_lock
获得共享锁,而写者线程使用 std::unique_lock
获得独占锁。这样,多个读者可以同时读取,而写者会独占地修改共享资源。
以下是对 std::mutex
,std::unique_lock
,std::recursive_mutex
,和 std::shared_mutex
的特点进行比较的表格:
特点 | std::mutex | std::unique_lock | std::recursive_mutex | std::shared_mutex |
---|---|---|---|---|
类型 | 互斥锁 | 可锁定、可解锁的锁 | 递归互斥锁 | 共享/独占互斥锁 |
RAII 风格 | 有(使用 std::lock_guard ) | 有 | 有 | 有(std::unique_lock ) |
支持条件变量 | 不支持 | 支持 | 不支持 | 支持 |
是否支持递归 | 不支持 | 不支持 | 支持 | 不支持 |
多线程性能 | 适用于大多数场景,较轻量级 | 较为灵活,适用于复杂的场景 | 适用于需要递归锁的场景 | 适用于读多写少的场景 |
锁定粒度 | 整个作用域内的代码 | 可以在较小的范围内进行锁定和解锁 | 整个作用域内的代码 | 可以同时支持独占和共享访问 |
死锁风险 | 高(如果未正确解锁,可能导致死锁) | 低(通过 std::lock() 可以避免死锁) | 递归锁允许同一线程多次获取锁,小心死锁风险 | 低(支持共享和独占访问,适当使用可以减少死锁风险) |
内存开销 | 低(较为轻量级) | 较高(提供了更多的功能) | 较高(需要额外的信息来支持递归锁) | 较高(需要维护更多状态信息) |
这个比较表格总结了这些锁的主要特点,但具体的选择取决于你的应用场景和需求。通常来说,std::mutex
是最基本的锁,而 std::unique_lock
提供了更多的灵活性,特别是在需要支持条件变量的情况下。std::recursive_mutex
对于需要在同一线程中多次获取锁的递归情况很有用。std::shared_mutex
则适用于读多写少的场景,提供了更好的并发性能。
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。 如若内容造成侵权/违法违规/事实不符,请联系我的编程经验分享网邮箱:veading@qq.com进行投诉反馈,一经查实,立即删除!