mutex：std::shared_timed_mutex::try_lock_shared

引入

在现代C++编程中，多线程的使用变得极为普遍，无论是在服务器编程、GUI应用，还是在高并发的网络环境中，合理的资源管理和同步机制至关重要。C++11及未来的版本提供了 <mutex> 头文件，其中包含多种互斥量的实现。C++17 延续这一理念，引入了 std::shared_timed_mutex，一种增强的互斥量，允许多个线程共享读取同一数据而不互相干扰。std::shared_timed_mutex::try_lock_shared 则是这个类的优秀特性，支持线程尝试以共享方式获取锁，这种设计特别适合读多写少的场合，帮助程序高效地利用并发能力。

1. 特性与函数介绍

1.1 特性

• 时间限制获取共享锁：try_lock_shared 允许线程尝试在争用状态下获取共享锁，若未能在一定条件下获取，则立即返回，避免线程因为锁被占用而被阻塞。
• 多线程共享访问：多个线程能够并发地调用 try_lock_shared 来读取数据，而不会互相阻塞，这在读操作频率高的场景中显得特别重要。
• 增强系统性能：在高并发情况下，这种机制能显著提高读取性能，减少因锁竞争引发的性能损失。

1.2 函数语法

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

#include <mutex>

class shared_timed_mutex : public mutex {
public:
    bool try_lock_shared(); // 尝试获取共享锁
    ...
};

• 返回值：如果成功获取共享锁，返回 true；如果锁不可用，返回 false。

2. 完整示例代码

以下示例展示了如何使用 std::shared_timed_mutex::try_lock_shared 在多线程环境中安全访问共享数据。

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

std::shared_timed_mutex st_mutex;           // 共享时间互斥锁
std::vector<int> sharedData;                 // 共享数据容器

// 读取数据的函数
void readData() {
    // 尝试获取共享锁，若成功读取数据
    if (st_mutex.try_lock_shared()) {
        std::cout << "Thread " << std::this_thread::get_id() 
                  << " read values: ";
        for (const auto& val : sharedData) {
            std::cout << val << " ";  // 输出共享数据内容
        }
        std::cout << std::endl;
        st_mutex.unlock_shared(); // 释放共享锁
    } else {
        std::cout << "Thread " << std::this_thread::get_id() 
                  << " could not acquire shared lock." << std::endl;
    }
}

// 写入数据的函数
void writeData(int value) {
    st_mutex.lock(); // 申请独占锁
    sharedData.push_back(value); // 写入数据
    std::cout << "Thread " << std::this_thread::get_id() 
              << " wrote value: " << value << std::endl;
    st_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 st_mutex; 用于控制对共享数据的访问，同时定义一个用于存储共享数据的 std::vector<int> sharedData;。

3. 定义读取函数：

   • 在 readData 函数中，调用 try_lock_shared() 尝试获取共享锁，成功时读取存储的数据并输出，并在完成后使用 unlock_shared() 释放锁；若无权访问，则输出状态信息。

4. 定义写入函数：

   • writeData 函数通过 lock() 获取独占锁，安全写入新数据，最后调用 unlock() 释放锁。

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

   • 在 main 函数中，启动一定数量的读写线程，通过 join() 等待其执行完毕。

4. 适用场景分析

4.1 读多写少场景

在许多场合，如配置管理、日志读取等，读操作远多于写操作，使用 try_lock_shared 允许多个线程并发读取，而不会阻塞，提升系统性能。

4.2 情况复杂的访问需求

在实时数据获取和处理要求极高的系统（如监控系统、数据可视化平台）中，允许多个线程同时读取数据，即使由写入线程引发锁的争用。

4.3 网络与数据库应用

在高并发的Web应用或数据库访问情境中，通过共享锁避免由于锁竞争引发响应缓慢，使得应用的表现更加平滑。

5. 总结

std::shared_timed_mutex::try_lock_shared 是 C++ 多线程环境管理共享资源的重要工具。它在多读少写的应用场景中提供了强大的性能支持，通过合理应用共享锁机制，不仅提升了数据读取效率，还有效管理了资源的并发访问。掌握这一特性的使用将为开发者提供更强的并发编程能力，能够设计出更高效、稳健的多线程应用。通过对这个机制的理解与实践，开发者能够有效应对现代多线程程序面临的挑战，在复杂的并发环境中游刃有余。