mutex：std::shared_timed_mutex::lock_shared

引入

在现代 C++ 开发中，随着多线程编程的广泛应用，线程安全和一致性成为了重中之重。为了支持各种并发场景，C++11 引入了 <mutex> 头文件，提供了多种锁的实现。在 C++17 中，std::shared_timed_mutex 被加入它的行列，为开发者在多线程环境下提供了更高效的数据访问控制。std::shared_timed_mutex::lock_shared 方法允许多个线程并发地同一时间安全地读取共享资源，而不互相干扰。这种方法在读多写少的应用场景中，能够显著提升性能。

1. 特性与函数介绍

1.1 特性

• 共享访问：lock_shared 方法允许多个线程同时对共享数据进行读取，在写入时采用独占锁的设计，确保数据一致性。
• 防止数据竞用：在写操作未完成时，lock_shared 会阻止丢失数据或产生竞争条件的情况，使得线程间的访问变得安全。
• 提升并发性能：此机制特别适合高频读操作与低频写操作的场合，充分利用并发的优势，以提升整个系统的性能。

1.2 函数语法

std::shared_timed_mutex::lock_shared 的基本语法如下：

#include <mutex>

class shared_timed_mutex : public mutex {
public:
    void lock_shared(); // 获取共享锁
    ...
};

• 无参数：该函数调用时不需要传入参数。
• 无返回值：成功获取共享锁后不会返回值。

2. 完整示例代码

下面的示例代码展示了如何使用 std::shared_timed_mutex::lock_shared 在多线程环境中安全地读取共享数据。

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

std::shared_timed_mutex sh_mutex;   // 定义共享时间互斥锁
std::vector<int> shared_data;        // 共享数据容器

// 读数据的函数
void readData() {
    sh_mutex.lock_shared(); // 获取共享锁
    std::cout << "Thread " << std::this_thread::get_id() 
              << " read values: ";
    for (const auto& val : shared_data) {
        std::cout << val << " "; // 输出共享数据
    }
    std::cout << std::endl;
    sh_mutex.unlock_shared(); // 释放共享锁
}

// 写数据的函数
void writeData(int value) {
    sh_mutex.lock(); // 申请独占锁
    shared_data.push_back(value); // 写入数据
    std::cout << "Thread " << std::this_thread::get_id() 
              << " wrote value: " << value << std::endl;
    sh_mutex.unlock(); // 释放独占锁
}

int main() {
    const int numWriters = 2;  // 定义写线程数量
    const int numReaders = 5;   // 定义读线程数量
    std::vector<std::thread> writers;
    std::vector<std::thread> readers;

    // 启动写线程
    for (int i = 0; i < numWriters; ++i) {
        writers.emplace_back(writeData, (i + 1) * 10); // 传入写入数值
    }

    // 启动读线程
    for (int i = 0; i < numReaders; ++i) {
        readers.emplace_back(readData);
    }

    // 等待所有线程完成
    for (auto& writer : writers) {
        writer.join();
    }
    for (auto& reader : readers) {
        reader.join();
    }

    return 0;
}

3. 代码解析

1. 引入必要的头文件：

   • 示例中导入了 <iostream>、<thread>、<shared_mutex> 和 <vector>，用于支持多线程操作及访问互斥量。

2. 定义共享数据和互斥锁：

   • 创建 std::shared_timed_mutex sh_mutex; 以管理线程对共享数据的安全访问，同时定义一个干果共享数据的容器 std::vector<int> shared_data;。

3. 定义读取函数：

   • 在 readData 函数中，使用 sh_mutex.lock_shared() 获取共享锁，读取共享数据并输出，最后通过 sh_mutex.unlock_shared() 释放锁。

4. 定义写入函数：

   • 在 writeData 函数中，通过 sh_mutex.lock() 获取独占锁以进行数据写入，并在结束后释放锁。

5. 主函数中的线程管理：

   • 在 main 函数中，创建多个写线程和读线程，利用 join() 等待所有线程执行完成。

4. 适用场景分析

4.1 读多写少的情况

在数据读取操作频繁而设计修改较少的场景中，相比较于使用普通互斥锁，std::shared_timed_mutex 可以有效降低阻塞的情况。

4.2 数据监控与分析

在需要持续读取和分析运行数据的应用上（如监控系统），多个线程可借助共享锁同时读取共享数据，而不互相干扰。

4.3 实时收藏应用

在聊天应用或社交媒体中同时进行多用户在线评论、阅读互动时，多个用户需要同时读取信息而不等待，这时简洁利用该功能将有助于提升用户体验。

5. 总结

std::shared_timed_mutex::lock_shared 为并发C++程序的开发提供了强大的数据管理能力。它的多线程共享锁功能使得在面对高并发的情况下，资源的管理变得更加高效，与此同时，保持了数据的安全性。理解与应用这一机制不仅有助于优化程序性能，更为开发复杂多线程应用提供了便利。因此，掌握其特性和使用技巧，将对提高开发者在多线程环境中的编程能力有很大帮助。通过有效运用该函数，开发者能够构建出更为高效和稳定的应用程序。