寻求folly::Synchronized的自包含仅头文件功能等效替代方案

当然有，你可以自己实现一个极简版本（仅依赖C++标准库），或者使用轻量级的第三方仅头文件库。以下是具体方案：

一、手动实现极简版 #

folly::Synchronized的核心是将对象与锁绑定，提供RAII风格的线程安全访问，核心逻辑不复杂，下面是一个仅头文件的实现：

#ifndef SYNCHRONIZED_H
#define SYNCHRONIZED_H

#include <mutex>
#include <functional>
#include <utility>

template <typename T, typename Mutex = std::mutex>
class Synchronized {
public:
    // 转发构造参数给被保护对象
    template <typename... Args>
    explicit Synchronized(Args&&... args) : data_(std::forward<Args>(args)...) {}

    // RAII锁持有者，自动管理锁生命周期
    class LockedAccess {
    public:
        explicit LockedAccess(Synchronized& sync) : sync_(sync), lock_(sync.mutex_) {}
        LockedAccess(LockedAccess&&) noexcept = default;

        // 禁止拷贝
        LockedAccess(const LockedAccess&) = delete;
        LockedAccess& operator=(const LockedAccess&) = delete;

        // 提供对被保护对象的访问
        T* operator->() { return &sync_.data_; }
        const T* operator->() const { return &sync_.data_; }
        T& operator*() { return sync_.data_; }
        const T& operator*() const { return sync_.data_; }

    private:
        Synchronized& sync_;
        std::unique_lock<Mutex> lock_;
    };

    // 获取带锁的对象访问器
    LockedAccess lock() { return LockedAccess(*this); }
    LockedAccess lock() const { return LockedAccess(const_cast<Synchronized&>(*this)); }

    // 执行lambda操作，自动加锁解锁（对应folly的with()）
    template <typename Func>
    auto with(Func&& func) -> decltype(func(std::declval<T&>())) {
        std::lock_guard<Mutex> lock(mutex_);
        return func(data_);
    }

    template <typename Func>
    auto with(Func&& func) const -> decltype(func(std::declval<const T&>())) {
        std::lock_guard<Mutex> lock(mutex_);
        return func(data_);
    }

private:
    mutable Mutex mutex_;
    T data_;
};

#endif // SYNCHRONIZED_H

实现特点 #

• 仅依赖C++11及以上标准库，无外部依赖
• 支持自定义锁类型（默认用std::mutex，可替换为std::shared_mutex实现读写锁）
• 完全复刻folly::Synchronized的核心用法：

  Synchronized<std::vector<int>> sync_vec;
  
  // 方式1：RAII锁访问
  {
      auto locked = sync_vec.lock();
      locked->push_back(42);
  }
  
  // 方式2：用with()执行批量操作
  sync_vec.with([](std::vector<int>& vec) {
      vec.push_back(100);
      vec.pop_back();
  });
  

二、使用第三方仅头文件库 #

如果你不想自己维护实现，可以用Boost.SynchronizedValue（仅头文件模块），它的设计和folly::Synchronized高度相似：

• 用法：boost::synchronized_value<T>
• 支持lock()获取带锁对象，apply()方法对应folly的with()
• 只需包含<boost/synchronized_value.hpp>即可，无需链接Boost库

注意事项 #

• 如果你需要folly::Synchronized的高级特性（比如锁升级、超时锁），可以在手动实现中扩展LockedAccess类，添加try_lock()等方法
• 自定义锁类型时，确保锁满足C++标准库的BasicLockable要求

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