现代C++是否提供针对非平凡类型的内置线程安全包装器？

你的手写Locker类实现是正确的，但现代C++提供了几个更贴合需求的标准库替代方案，尤其适配你提到的异步超时更新+多线程安全访问场景：

1. std::shared_mutex 读写锁优化（C++17+） #

如果你的场景是读多写少（异步更新频率低，多数线程为读操作），用std::shared_mutex替代普通std::mutex可以提升性能：读线程共享锁，允许多个线程同时读取；写线程独占锁，保证更新的原子性。

示例实现：

#include <shared_mutex>

template<typename T>
class ThreadSafeValue final {
    mutable std::shared_mutex mutex;
    T value{};
public:
    explicit ThreadSafeValue(const T& value_) : value(value_) {}
    explicit ThreadSafeValue(T&& value_) : value(std::move(value_)) {}

    // 读操作：共享锁，支持多线程同时读取
    T get() const {
        std::shared_lock<std::shared_mutex> lock(mutex);
        return value;
    }

    // 写操作：独占锁，保证更新原子性
    void set(const T& value_) {
        std::unique_lock<std::shared_mutex> lock(mutex);
        value = value_;
    }

    // 支持移动语义，减少拷贝开销
    void set(T&& value_) {
        std::unique_lock<std::shared_mutex> lock(mutex);
        value = std::move(value_);
    }
};

2. std::atomic<std::shared_ptr<T>> 无锁原子访问（C++20+） #

如果允许用共享指针封装数据，C++20正式支持std::atomic<std::shared_ptr<T>>，可以实现无锁的原子更新与访问。这种方案的核心是原子交换shared_ptr，读取时拿到的是稳定的副本，后续访问无需加锁，适合更新频繁的场景。

示例实现：

#include <memory>
#include <atomic>

template<typename T>
class AtomicSharedValue final {
    std::atomic<std::shared_ptr<T>> value;
public:
    explicit AtomicSharedValue(const T& value_) 
        : value(std::make_shared<T>(value_)) {}
    explicit AtomicSharedValue(T&& value_) 
        : value(std::make_shared<T>(std::move(value_))) {}

    std::shared_ptr<const T> get() const {
        // memory_order_acquire保证读取到最新的指针状态
        return value.load(std::memory_order_acquire);
    }

    void set(const T& value_) {
        // memory_order_release保证写入的指针状态对其他线程可见
        value.store(std::make_shared<T>(value_), std::memory_order_release);
    }

    void set(T&& value_) {
        value.store(std::make_shared<T>(std::move(value_)), std::memory_order_release);
    }
};

3. 结合std::condition_variable实现超时异步更新 #

针对你超时后异步更新的需求，可以在上述方案基础上搭配std::condition_variable_any，实现后台线程等待超时后自动更新，还能让读线程可选等待更新完成。

基于std::shared_mutex的示例：

#include <shared_mutex>
#include <condition_variable>
#include <thread>
#include <chrono>

template<typename T>
class TimedUpdatableValue final {
    mutable std::shared_mutex mutex;
    std::condition_variable_any cv;
    T value{};
    bool has_updated = false;

public:
    explicit TimedUpdatableValue(const T& value_) : value(value_) {}

    T get() const {
        std::shared_lock<std::shared_mutex> lock(mutex);
        return value;
    }

    // 启动后台线程，超时后自动更新数据
    void async_update_after(std::chrono::milliseconds timeout, const T& new_value) {
        std::thread([this, timeout, new_value]() {
            std::this_thread::sleep_for(timeout);
            std::unique_lock<std::shared_mutex> lock(mutex);
            value = new_value;
            has_updated = true;
            cv.notify_all(); // 通知等待的读线程
        }).detach();
    }

    // 等待更新完成或超时后读取数据
    T get_wait_for(std::chrono::milliseconds timeout) const {
        std::shared_lock<std::shared_mutex> lock(mutex);
        cv.wait_for(lock, timeout, [this]() { return has_updated; });
        has_updated = false; // 重置更新标记
        return value;
    }
};

对你手写Locker的优化建议 #

你的实现逻辑没问题，可补充以下细节提升实用性：

• 增加移动构造/赋值重载，避免不必要的拷贝
• 将get()设为const成员函数，支持const对象的访问
• 若需要灵活控制锁的生命周期，可替换std::lock_guard为std::unique_lock

内容的提问来源于stack exchange，提问作者Alvov1