shared_mutex：std::shared_lock::try_lock_until

引入

在多线程编程环境中，高效地管理对共享资源的访问是开发者面临的主要挑战之一。C++标准库引入了 <mutex> 和 <shared_mutex> 头文件，提供了一系列同步工具以帮助解决这一问题。其中，std::shared_lock<Mutex> 被设计用于允许多个线程并发地读取资源，确保在写入时的数据一致性。C++17 引入的 try_lock_until 方法允许线程在给定的时间点之前尝试获取共享锁，从而增加了对锁的控制灵活性。这为读取频繁、写入较少的应用场景提供了极大的帮助，使得程序能在高负载条件下保持良好的响应性。

1. 特性与函数介绍

1.1 特性

• 定时尝试获取锁：使用 try_lock_until 方法，调用线程可以指定一个时间点来尝试获取共享锁，如果在规定的时间点之前无法成功获取锁，方法会立即返回失败。
• 多个线程的并发读取：共享锁机制允许多个线程同时持有锁进行读取，在写入时则要求进入独占锁状态，从而提升了系统的并发性能。
• 提高系统的响应速度：在多线程读取的情况下，使用该功能可以避免阻塞，有助于提升整体系统性能和用户体验。

1.2 函数语法

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

• 参数：

  • timeout_time：期望在该时间点之前获得共享锁的时间点，类型为 std::chrono::steady_clock::time_point。

• 返回值：

  • 如果成功获取共享锁，返回 true；若未能在规定时间内获得锁，则返回 false。

2. 完整示例代码

以下示例代码展示了如何使用 std::shared_lock<Mutex>::try_lock_until 在多线程环境中安全管理共享资源的访问。

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

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

// 读取数据的函数
void readData() {
    auto timeout = std::chrono::steady_clock::now() + std::chrono::milliseconds(100);
    std::shared_lock<std::shared_mutex> lock(sh_mutex); // 获取共享保证期间的锁
    if(lock.try_lock_until(timeout)) { // 尝试获取共享锁
        std::cout << "Thread " << std::this_thread::get_id() 
                  << " reading values: ";
        for (const auto& val : sharedData) {
            std::cout << val << " "; // 输出共享数据
        }
        std::cout << std::endl;
        lock.unlock(); // 释放共享锁
    } 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_until() 获得共享锁，成功后的数据读取过程，在处理后会自动解锁；若等待超时，则输出提示信息。

4. 写入函数：

   • 在 writeData 核心函数中，通过 std::unique_lock 获取独占锁，确保写入操作的线程安全性。

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

   • 在 main 函数中，主要负责启动写线程和读线程，并利用 join() 等待所有线程的完成。

4. 适用场景分析

4.1 读多写少的情况

在许多实时数据存取和问询场合，读取操作远超写入，实例使用 try_lock_until 可有效提高性能。

4.2 实时监控与数据展示

适合监控系统中，多个线程并行获取共享信息，同时应用数据分析。该机制可快速应对多个读请求。

4.3 高并发的服务器负载

适用于高并发的Web应用程序场景中，能够优化多线程存取，减少请求队列的堵塞和响应该机制的灵活性。

5. 总结

std::shared_lock<Mutex>::try_lock_until 是 C++ 并发编程中一种重要的工具，它允许线程在指定时间内尝试获得共享锁，有效提升了资源访问的灵活性和高并发性能。通过合理地使用这一特性，开发者能够在多线程环境中更好地管理共享资源，提高程序的效率与安全性，这在现代复杂应用中至关重要。掌握这一机制，不仅提升了写作效率，并且为设计更为健壮的多线程系统打下了良好基础。