shared_mutex：std::shared_lock::try_lock_for

引入

在现代C++编程中，随着多线程应用的广泛使用，应对共享资源的并发访问变得十分重要。C++11引入的 <mutex> 和 <shared_mutex> 头文件为开发者提供了丰富的同步工具，以确保数据的一致性和安全性。其中，std::shared_lock<Mutex> 提供了一种以共享互斥量的参考方式来支持多个线程的并发读取。C++17 引入的 try_lock_for 方法使得线程可以尝试以共享锁的方式在给定的时间内获取锁，这种机制在允许高效并发访问的同时也提高了程序应对高负载情况的灵活性和鲁棒性。

1. 特性与函数介绍

1.1 特性

• 定时尝试获得锁：try_lock_for 允许调用线程在指定的时间段内尝试获取共享锁，如果在该时间内没有获得锁，则返回失败，避免了不必要的阻塞。
• 增强的并发能力：多个线程可以同时拥有共享锁，允许多个线程并发地读取共享数据，而不互相干扰，适合读多写少的应用场景。
• 提高系统响应性：此功能允许开发者更灵活地管理并发逻辑，提供快速失败的选项，有助于在负载过重的情况下降低待锁请求的响应时间。

1.2 函数语法

std::shared_lock<Mutex>::try_lock_for 的基本语法如下：

#include <shared_mutex>
#include <chrono>

template <class Mutex>
class shared_lock {
public:
    bool try_lock_for(std::chrono::milliseconds duration); // 尝试在指定时间内获取共享锁
    ...
};

• 参数：

  • duration：std::chrono::milliseconds 类型，表示在获取锁时允许等待的最大时间。

• 返回值：成功获取共享锁时返回 true，若在指定时间内未能成功获取到锁，则返回 false。

2. 完整示例代码

下面的示例展示了如何使用 std::shared_lock<Mutex>::try_lock_for 在多线程环境中安全地获取共享锁，并进行对共享资源的访问管理。

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

std::shared_mutex sh_mutex;          // 共享互斥量
std::vector<int> sharedData;         // 共享数据容器

// 读取数据的函数
void readData() {
    if (sh_mutex.try_lock_for(std::chrono::milliseconds(100))) { // 尝试获取共享锁
        std::cout << "Thread " << std::this_thread::get_id() 
                  << " reading values: ";
        for (const auto& val : sharedData) {
            std::cout << val << " "; // 输出共享数据
        }
        std::cout << std::endl;
        sh_mutex.unlock_shared();      // 释放共享锁
    } else {
        std::cout << "Thread " << std::this_thread::get_id() 
                  << " could not acquire shared lock in time." << std::endl;
    }
}

// 写入数据的函数
void writeData(int value) {
    // 使用独占锁获取互斥量
    std::unique_lock<std::shared_mutex> lock(sh_mutex); 
    sharedData.push_back(value); // 写入数据
    std::cout << "Thread " << std::this_thread::get_id() 
              << " wrote value: " << value << std::endl;
    // mutex 将在 lock 的生命周期结束时自动解锁
}

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_mutex sh_mutex; 以负责对共享数据访问的同步，同时定义一个 std::vector<int> sharedData; 用于存储共享数据。

3. 读取函数：

   • 在 readData 函数中，尝试使用 try_lock_for() 方法在 100 毫秒内获取共享锁。如果成功，获取后读取并输出存储的数据；如果获取失败，输出相应提示，确保程序在高并发情况下的响应性。

4. 写入函数：

   • writeData 使用 std::unique_lock 获取独占锁，这在进行数据写入期间确保对共享数据的准确性。

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

   • 在 main 函数中，创建多个写线程和读线程并分别启动，然后使用 join() 等待所有线程完成它们的操作。

4. 适用场景分析

4.1 读多写少的环境

对于许多需要频繁读取但较少写入的应用场景，如配置文件读取、观测数据监控，try_lock_for 可以显著提升多线程访问的效率。

4.2 实时数据分析

在实时数据分析场景中，多个线程需要并行访问共享数据而算法会影响性能，使用共享锁能有效增强计算性能和资源管理能力。

4.3 网络服务和缓存策略

在高并发的 Web 服务背景中，用户可能会频繁查询相同的数据，有效使用 try_lock_for 保障流量，并确保资源能够快速处理。

5. 总结

std::shared_lock<Mutex>::try_lock_for 是 C++ 提供的重要特性，允许多个线程灵活地共享访问资源，同时在资源竞争中应用时间控制策略。因此，掌握这一机制对于提升现代多线程应用性能至关重要。通过合理应用这一方法，开发者能够有效提升系统的响应速度，实现在高并发环境下的数据安全性和一致性。在高效的多线程开发中，借助 try_lock_for，能够为任务处理分配合适的线程，使得整个应用具备更高透支抵抗力和灵活性。