c++,mutex,unique_lock,recursive_mutex,shared_mutex对比分析

当处理多线程并发时，正确使用锁是确保线程安全的关键。

1. std::mutex（互斥锁）：

std::mutex 是C++标准库提供的最基本的锁。它的基本使用如下：

#include 
#include 
#include 

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 
#include 
#include 

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 
#include 
#include 

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 的主要特点和用法：

1. 共享锁（Shared Lock）：

   • 多个线程可以同时获得共享锁，这允许它们并发地读取共享资源。
   • 共享锁使用 std::shared_lock 来获取。

   #include 
   
   std::shared_mutex mySharedMutex;
   
   void readOperation() {
       std::shared_lock<std::shared_mutex> lock(mySharedMutex);
       // 读取共享资源的代码
   }
   

2. 独占锁（Exclusive Lock）：

   • 只有一个线程可以获得独占锁，这使得它能够独占地修改共享资源。
   • 独占锁使用 std::unique_lock 来获取。

   #include 
   
   std::shared_mutex mySharedMutex;
   
   void writeOperation() {
       std::unique_lock<std::shared_mutex> lock(mySharedMutex);
       // 修改共享资源的代码
   }
   

3. 避免写者饥饿（Writer Starvation Avoidance）：

   • std::shared_mutex 的设计旨在避免写者饥饿问题，即允许读者和写者以公平的方式争夺锁。

4. 适用于读多写少的场景：

   • std::shared_mutex 在读多写少的情况下表现得较为优越，因为多个线程可以同时获得共享锁，提高了并发性能。

5. 注意事项：

   • 使用 std::shared_lock 进行读取操作，使用 std::unique_lock 进行写入操作。
   • 避免在写入操作中使用共享锁，以免破坏写者的互斥性。

#include 
#include 
#include 
#include 

int sharedData=0;
std::shared_mutex mySharedMutex;

void readOperation(int id) {
    //std::shared_lock lock(mySharedMutex);
    mySharedMutex.lock_shared();//手动控制
    // 读取共享资源的代码
    std::cout << "Reader " << id << " reading data: " << sharedData << std::endl;
    mySharedMutex.unlock_shared();//手动控制
}

void writeOperation(int id) {
    //std::unique_lock 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 则适用于读多写少的场景，提供了更好的并发性能。