多线程同步原语std::shared_timed_mutex 和 std::shared_lock

std::shared_timed_mutex 和 std::shared_lock 是 C++11 标准库中提供的多线程同步原语，用于实现更灵活的读写锁机制。它们允许多个线程同时读取共享数据，但在写入时，只允许一个线程独占访问。以下是对这两个类的详细介绍：

std::shared_timed_mutex

std::shared_timed_mutex 是一个读写锁，它允许多个线程同时持有共享锁（用于读操作），但只允许一个线程持有独占锁（用于写操作）。当某个线程持有独占锁时，其他任何尝试获取共享锁或独占锁的线程都会被阻塞，直到独占锁被释放。

std::shared_timed_mutex 提供了以下主要成员函数：

• lock_shared(): 获取共享锁，如果当前有独占锁，则阻塞。
• try_lock_shared(): 尝试获取共享锁，如果成功则返回 true，否则返回 false，不阻塞。
• try_lock_shared_for(duration): 尝试在指定的时间段内获取共享锁，如果成功则返回 true，否则返回 false。
• lock(): 获取独占锁，如果当前有共享锁或独占锁，则阻塞。
• try_lock(): 尝试获取独占锁，如果成功则返回 true，否则返回 false，不阻塞。
• try_lock_for(duration): 尝试在指定的时间段内获取独占锁，如果成功则返回 true，否则返回 false。
• unlock(): 释放当前持有的锁（无论是共享锁还是独占锁）。

std::shared_lock

std::shared_lock 是一个锁管理类，专门用于管理 std::shared_timed_mutex 或 std::shared_mutex 的共享锁。它简化了获取和释放共享锁的操作，并提供了一些附加功能，比如延迟锁定、超时锁定等。

std::shared_lock 提供了以下主要构造函数和成员函数：

• shared_lock(): 创建一个未锁定的 shared_lock。
• shared_lock(mutex_type& m): 创建一个 shared_lock 并尝试锁定给定的 mutex_type（std::shared_timed_mutex 或 std::shared_mutex）。如果锁定失败，则抛出异常。
• shared_lock(mutex_type& m, std::defer_lock_t t): 创建一个未锁定的 shared_lock，但关联到给定的 mutex_type。
• shared_lock(mutex_type& m, std::try_to_lock_t t): 尝试锁定给定的 mutex_type，如果成功则锁定，否则创建一个未锁定的 shared_lock。
• shared_lock(mutex_type& m, const std::chrono::time_point<Clock, Duration>& abs_time): 尝试在给定的绝对时间点之前锁定给定的 mutex_type。如果成功则锁定，否则创建一个未锁定的 shared_lock。
• shared_lock(mutex_type& m, const std::chrono::duration<Rep, Period>& rel_time): 尝试在给定的相对时间段内锁定给定的 mutex_type。如果成功则锁定，否则创建一个未锁定的 shared_lock。
• lock(): 锁定关联的互斥量（如果尚未锁定）。
• try_lock(): 尝试锁定关联的互斥量，如果成功则返回 true，否则返回 false。
• try_lock_for(duration): 尝试在指定的时间段内锁定关联的互斥量，如果成功则返回 true，否则返回 false。
• try_lock_until(time_point): 尝试在给定的时间点之前锁定关联的互斥量，如果成功则返回 true，否则返回 false。
• unlock(): 释放锁（如果持有）。
• owns_lock(): 检查 shared_lock 是否持有锁。
• operator bool(): 检查 shared_lock 是否持有锁（返回 owns_lock() 的结果）。

使用示例

以下是一个简单的示例，展示了如何使用 std::shared_timed_mutex 和 std::shared_lock：

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

std::shared_timed_mutex sharedMutex;
int sharedData = 0;

void reader(int id) {
    while (true) {
        std::shared_lock<std::shared_timed_mutex> lock(sharedMutex);
        std::cout << "Reader " << id << " reads: " << sharedData << std::endl;
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }
}

void writer(int id, int value) {
    std::unique_lock<std::shared_timed_mutex> lock(sharedMutex);
    sharedData = value;
    std::cout << "Writer " << id << " writes: " << sharedData << std::endl;
    std::this_thread::sleep_for(std::chrono::milliseconds(200));
}

int main() {
    std::thread r1(reader, 1);
    std::thread r2(reader, 2);
    std::thread w1(writer, 1, 42);
    std::thread w2(writer, 2, 84);

    r1.join();
    r2.join();
    w1.join();
    w2.join();

    return 0;
}

在这个示例中，两个读者线程使用 std::shared_lock 来获取共享锁并读取 sharedData，而两个写者线程使用 std::unique_lock 来获取独占锁并写入 sharedData。这样，读者可以并发读取，但写者写入时会阻塞其他读者和写者。