1. 项目概述在C网络编程中管理全局状态和共享资源一直是个棘手的问题。最近我在重构一个网络服务框架时发现多个线程频繁访问同一个逻辑处理类导致资源竞争和性能瓶颈。通过引入单例模式重构后不仅解决了线程安全问题还使代码结构更加清晰。今天就来分享如何用单例模式优雅地实现网络编程中的逻辑类。单例模式特别适合以下场景需要严格控制实例数量的资源管理器频繁被多个模块调用的工具类包含共享状态的核心逻辑处理器在网络编程中像连接池管理、请求分发器、协议解析器等都是单例模式的典型应用场景。接下来我会结合具体代码展示从基础实现到线程安全的完整演进过程。2. 单例模式基础实现2.1 经典单例结构最基本的单例实现包含三个关键要素私有化构造函数静态获取实例方法静态实例指针class NetworkManager { public: static NetworkManager* getInstance() { if (!instance) { instance new NetworkManager(); } return instance; } void processRequest(const std::string data) { // 业务逻辑处理 } private: NetworkManager() default; // 私有构造函数 static NetworkManager* instance; }; // 静态成员初始化 NetworkManager* NetworkManager::instance nullptr;这种实现简单直接但在多线程环境下会有严重问题。当多个线程同时调用getInstance()时可能会创建多个实例。2.2 线程安全改进版为了解决线程安全问题最直接的方法是加锁class NetworkManager { public: static NetworkManager* getInstance() { std::lock_guardstd::mutex lock(mutex); if (!instance) { instance new NetworkManager(); } return instance; } private: static NetworkManager* instance; static std::mutex mutex; };虽然线程安全了但每次获取实例都要加锁会影响性能。实际上我们只需要在第一次创建实例时加锁。3. 现代C单例实现3.1 Meyers SingletonC11之后利用局部静态变量的线程安全特性可以实现更优雅的单例class NetworkManager { public: static NetworkManager getInstance() { static NetworkManager instance; return instance; } void handlePacket(const Packet packet) { // 处理网络数据包 } private: NetworkManager() default; ~NetworkManager() default; // 禁止拷贝 NetworkManager(const NetworkManager) delete; NetworkManager operator(const NetworkManager) delete; };这种实现方式线程安全C11保证局部静态变量初始化是线程安全的自动释放程序结束时自动调用析构引用返回避免指针可能为空的问题3.2 带模板的通用实现如果需要多个单例类可以提取通用逻辑到模板中templatetypename T class Singleton { public: static T getInstance() { static T instance; return instance; } protected: Singleton() default; virtual ~Singleton() default; Singleton(const Singleton) delete; Singleton operator(const Singleton) delete; }; // 使用示例 class LogicService : public SingletonLogicService { friend class SingletonLogicService; private: LogicService() default; public: void process(const Request req) { // 业务处理 } };4. 网络编程中的实际应用4.1 连接管理器实现在网络服务中连接管理是典型的单例应用场景class ConnectionManager : public SingletonConnectionManager { friend class SingletonConnectionManager; public: void addConnection(int sockfd) { std::lock_guardstd::mutex lock(mutex_); connections_.insert(sockfd); } void removeConnection(int sockfd) { std::lock_guardstd::mutex lock(mutex_); connections_.erase(sockfd); } size_t connectionCount() const { return connections_.size(); } private: ConnectionManager() default; std::unordered_setint connections_; mutable std::mutex mutex_; };4.2 协议分发器案例协议分发器通常也需要单例实现class ProtocolDispatcher { public: static ProtocolDispatcher getInstance() { static ProtocolDispatcher instance; return instance; } void registerHandler(int protocolId, HandlerFunc handler) { handlers_[protocolId] std::move(handler); } void dispatch(int protocolId, const ByteBuffer data) { auto it handlers_.find(protocolId); if (it ! handlers_.end()) { it-second(data); } } private: std::unordered_mapint, HandlerFunc handlers_; };5. 高级话题与优化5.1 单例的生命周期管理虽然Meyers Singleton会自动释放但有时我们需要控制释放时机class ControlledSingleton { public: static ControlledSingleton getInstance() { static std::unique_ptrControlledSingleton instance; if (!instance) { instance.reset(new ControlledSingleton()); } return *instance; } static void destroyInstance() { getInstance().instance.reset(); } private: static std::unique_ptrControlledSingleton instance; };5.2 单例的依赖注入为了便于测试可以考虑将单例抽象为接口class IService { public: virtual void execute() 0; virtual ~IService() default; }; class RealService : public IService { // 实际实现 }; class ServiceLocator { public: static IService getService() { static std::unique_ptrIService service std::make_uniqueRealService(); return *service; } static void setService(std::unique_ptrIService newService) { getService().service std::move(newService); } };6. 常见问题与解决方案6.1 单例的线程安全陷阱即使使用Meyers Singleton成员变量的访问仍需注意线程安全class ThreadSafeSingleton { public: static ThreadSafeSingleton getInstance() { static ThreadSafeSingleton instance; return instance; } void addItem(int item) { std::lock_guardstd::mutex lock(itemsMutex_); items_.push_back(item); } std::vectorint getItems() const { std::lock_guardstd::mutex lock(itemsMutex_); return items_; } private: std::vectorint items_; mutable std::mutex itemsMutex_; };6.2 单例初始化顺序问题当多个单例相互依赖时初始化顺序可能成为问题。解决方案使用construct on first use惯用法将依赖关系改为运行时获取使用单例管理器统一初始化class Dependency { public: static Dependency getInstance() { static Dependency instance; return instance; } }; class MainService { public: static MainService getInstance() { static MainService instance(Dependency::getInstance()); return instance; } private: MainService(Dependency dep) : dep_(dep) {} Dependency dep_; };7. 性能优化技巧7.1 双重检查锁定模式对于性能敏感的场景可以使用双重检查锁定class OptimizedSingleton { public: static OptimizedSingleton getInstance() { OptimizedSingleton* tmp instance.load(std::memory_order_acquire); if (tmp nullptr) { std::lock_guardstd::mutex lock(mutex); tmp instance.load(std::memory_order_relaxed); if (tmp nullptr) { tmp new OptimizedSingleton(); instance.store(tmp, std::memory_order_release); } } return *tmp; } private: static std::atomicOptimizedSingleton* instance; static std::mutex mutex; };7.2 使用call_once保证一次性初始化C11提供了更优雅的一次性初始化机制class OnceSingleton { public: static OnceSingleton getInstance() { std::call_once(initFlag, OnceSingleton::initInstance); return *instance; } private: static void initInstance() { instance.reset(new OnceSingleton()); } static std::unique_ptrOnceSingleton instance; static std::once_flag initFlag; };8. 设计考量与替代方案8.1 何时使用单例模式适合使用单例的场景需要严格控制实例数量的资源如配置管理全局访问点且不需要多种实现的组件开销大的对象需要共享使用不适合的场景需要多态行为的服务需要测试替身的模块可能演变为多实例的场景8.2 单例的替代方案如果担心单例的全局状态问题可以考虑依赖注入通过构造函数传递依赖上下文对象将共享状态集中管理服务定位器运行时获取服务实例// 依赖注入示例 class Client { public: explicit Client(NetworkService service) : service_(service) {} void doWork() { service_.sendRequest(...); } private: NetworkService service_; };9. 实际项目中的经验分享在实际网络编程项目中单例模式的应用有几个关键经验日志系统的单例实现全局日志器通常实现为单例但要注意文件句柄的线程安全访问日志级别变化的原子性不同模块的日志分类class Logger : public SingletonLogger { public: void log(LogLevel level, const std::string message) { std::lock_guardstd::mutex lock(mutex_); if (level currentLevel_) { writeToFile(message); } } void setLevel(LogLevel level) { currentLevel_.store(level); } private: std::mutex mutex_; std::atomicLogLevel currentLevel_{LogLevel::Info}; };配置管理的陷阱配置文件读取通常也用单例但要注意热重载配置时的线程安全配置变更通知机制默认值的处理逻辑性能关键路径的优化对于高频调用的单例方法使用无锁数据结构减少锁的粒度考虑线程本地存储(TLS)优化class PerformanceCounter { public: static PerformanceCounter getInstance() { thread_local PerformanceCounter instance; return instance; } void increment() { count_; // 每个线程有自己的计数器 } private: std::atomicint count_{0}; };10. 测试与模拟技巧单例模式的一个主要缺点是难以测试。以下是几种解决方案提取接口将单例类抽象为接口测试时注入模拟实现class IDatabase { public: virtual QueryResult execute(const std::string sql) 0; virtual ~IDatabase() default; }; class Database : public SingletonDatabase, public IDatabase { // 实际实现 }; // 测试时 class MockDatabase : public IDatabase { QueryResult execute(const std::string sql) override { return TestData; // 返回测试数据 } };重置机制为单例添加重置方法仅用于测试class TestableSingleton { public: static TestableSingleton getInstance() { static TestableSingleton instance; return instance; } // 仅用于测试 static void resetForTesting() { getInstance() TestableSingleton(); } };使用依赖注入容器在应用启动时注册单例实例// 生产环境 Container::registerSingletonIDatabase, Database(); // 测试环境 Container::registerSingletonIDatabase, MockDatabase();11. 跨平台注意事项在不同平台上实现单例时需要注意DLL边界问题Windows动态库中的静态变量可能有多个实例解决方案显式导出获取实例的函数// 头文件中 #ifdef _WIN32 #define API __declspec(dllexport) #else #define API #endif class API SingletonInDLL { public: static SingletonInDLL getInstance(); };静态初始化顺序问题不同编译单元的静态变量初始化顺序未定义解决方案使用construct on first use模式信号处理安全在信号处理函数中调用单例可能不安全解决方案提前初始化或使用原子操作12. C17/20的改进现代C标准为单例模式带来了更多可能性inline静态成员C17简化了静态成员的定义class InlineSingleton { public: static InlineSingleton getInstance() { static InlineSingleton instance; return instance; } private: inline static std::mutex mutex_; // 无需cpp文件定义 };constexpr单例对于编译期确定的单例对象class ConstexprSingleton { public: static constexpr ConstexprSingleton getInstance() { static constexpr ConstexprSingleton instance; return instance; } constexpr int getValue() const { return 42; } };单例与协程C20协程环境下单例的使用注意事项class CoroutineSingleton { public: static CoroutineSingleton getInstance() { static CoroutineSingleton instance; return instance; } awaitablevoid asyncOperation() { co_await someAsyncWork(); } };13. 反模式与滥用警示虽然单例模式很有用但容易被滥用。以下是常见反模式上帝对象把太多功能塞进一个单例症状单例类有数十个方法承担多种职责解决按单一职责原则拆分隐藏的依赖在深层代码中直接调用单例症状难以追踪依赖关系测试困难解决通过构造函数显式传递依赖不必要的全局状态用单例管理本应是局部状态的数据症状单例中存储了应该属于特定上下文的数据解决评估是否真的需要全局访问生命周期混乱单例依赖其他单例形成复杂依赖网症状程序启动/关闭时出现奇怪问题解决明确初始化顺序或改用依赖注入14. 与其他模式的结合单例模式常与其他设计模式配合使用单例工厂模式单例工厂管理对象创建class ObjectFactory : public SingletonObjectFactory { public: std::unique_ptrObject create(ObjectType type) { auto it creators_.find(type); if (it ! creators_.end()) { return it-second(); } return nullptr; } void registerCreator(ObjectType type, CreatorFunc func) { creators_[type] std::move(func); } private: std::unordered_mapObjectType, CreatorFunc creators_; };单例观察者模式单例事件总线class EventBus : public SingletonEventBus { public: void subscribe(EventType type, CallbackFunc callback) { subscribers_[type].push_back(std::move(callback)); } void publish(EventType type, const EventData data) { for (auto cb : subscribers_[type]) { cb(data); } } private: std::unordered_mapEventType, std::vectorCallbackFunc subscribers_; };单例装饰器模式为单例添加扩展功能class EnhancedService : public IService { public: EnhancedService(IService base) : base_(base) {} void operation() override { preOperation(); base_.operation(); postOperation(); } private: IService base_; }; // 使用 auto base Service::getInstance(); EnhancedService enhanced(base);15. 网络编程中的典型应用在网络编程框架中单例模式常用于以下组件IO多路复用管理器统一管理epoll/kqueue等IO多路复用操作class IOManager : public SingletonIOManager { public: void registerSocket(int fd, EventCallback cb) { std::lock_guardstd::mutex lock(mutex_); epollAdd(fd); callbacks_[fd] std::move(cb); } void run() { while (running_) { int n epollWait(); handleEvents(n); } } private: std::unordered_mapint, EventCallback callbacks_; std::mutex mutex_; bool running_{true}; };协议工厂管理各种网络协议的创建class ProtocolFactory : public SingletonProtocolFactory { public: std::unique_ptrProtocol create(const std::string name) { auto it prototypes_.find(name); return it ! prototypes_.end() ? it-second-clone() : nullptr; } void registerProtocol(const std::string name, std::unique_ptrProtocol proto) { prototypes_[name] std::move(proto); } private: std::unordered_mapstd::string, std::unique_ptrProtocol prototypes_; };连接池管理数据库/网络连接复用class ConnectionPool : public SingletonConnectionPool { public: std::shared_ptrConnection acquire() { std::lock_guardstd::mutex lock(mutex_); if (pool_.empty()) { return createConnection(); } auto conn std::move(pool_.back()); pool_.pop_back(); return conn; } void release(std::shared_ptrConnection conn) { std::lock_guardstd::mutex lock(mutex_); pool_.push_back(std::move(conn)); } private: std::vectorstd::shared_ptrConnection pool_; std::mutex mutex_; };16. 性能关键型单例优化对于高性能网络编程单例实现需要特别优化无锁单例访问使用原子操作避免锁开销class LockFreeSingleton { public: static LockFreeSingleton getInstance() { static std::aligned_storage_tsizeof(LockFreeSingleton), alignof(LockFreeSingleton) storage; auto instance reinterpret_castLockFreeSingleton*(storage); static std::atomicbool initialized{false}; if (!initialized.load(std::memory_order_acquire)) { std::lock_guardstd::mutex lock(initMutex); if (!initialized.load(std::memory_order_relaxed)) { new (instance) LockFreeSingleton(); initialized.store(true, std::memory_order_release); } } return *instance; } private: static std::mutex initMutex; };线程本地单例每个线程有自己的单例实例class ThreadLocalSingleton { public: static ThreadLocalSingleton getInstance() { thread_local ThreadLocalSingleton instance; return instance; } // 线程特定的数据操作 void addToThreadData(int value) { threadData_.push_back(value); } private: std::vectorint threadData_; };热路径优化将高频访问路径与低频操作分离class OptimizedNetworkManager { public: static OptimizedNetworkManager getInstance() { static OptimizedNetworkManager instance; return instance; } // 高频调用无锁快速路径 void processPacket(const Packet packet) { auto handler getHandler(packet.type()); if (handler) { handler(packet); } } // 低频调用加锁维护操作 void registerHandler(PacketType type, PacketHandler handler) { std::lock_guardstd::mutex lock(mutex_); handlers_[type] std::move(handler); } private: PacketHandler getHandler(PacketType type) const { std::atomic_thread_fence(std::memory_order_acquire); auto it handlers_.find(type); return it ! handlers_.end() ? it-second : nullptr; } std::unordered_mapPacketType, PacketHandler handlers_; mutable std::mutex mutex_; };17. 单例在异步编程中的应用现代C异步编程中单例模式需要特别考虑协程安全单例确保单例在协程环境下的正确性class CoroutineSingleton { public: static CoroutineSingleton getInstance() { static CoroutineSingleton instance; return instance; } awaitablevoid asyncOperation() { co_await someAsyncWork(); co_return; } };异步初始化支持单例的异步初始化过程class AsyncInitSingleton { public: static awaitableAsyncInitSingleton getInstance() { static AsyncInitSingleton instance; co_await instance.initialize(); co_return instance; } private: awaitablevoid initialize() { if (!initialized_) { co_await loadConfig(); co_await setupResources(); initialized_ true; } } std::atomicbool initialized_{false}; };事件驱动单例单例作为事件处理器核心class EventProcessor : public SingletonEventProcessor { public: void postEvent(std::unique_ptrEvent event) { std::lock_guardstd::mutex lock(queueMutex_); eventQueue_.push(std::move(event)); cv_.notify_one(); } void run() { while (running_) { std::unique_lockstd::mutex lock(queueMutex_); cv_.wait(lock, [this]{ return !eventQueue_.empty() || !running_; }); if (!running_) break; auto event std::move(eventQueue_.front()); eventQueue_.pop(); lock.unlock(); handleEvent(*event); } } private: std::queuestd::unique_ptrEvent eventQueue_; std::mutex queueMutex_; std::condition_variable cv_; bool running_{true}; };18. 单例模式的内存模型考量理解单例模式的内存模型对编写正确并发程序至关重要内存顺序保证使用atomic确保正确的内存可见性class MemoryModelSingleton { public: static MemoryModelSingleton getInstance() { MemoryModelSingleton* tmp instance_.load(std::memory_order_acquire); if (tmp nullptr) { std::lock_guardstd::mutex lock(mutex_); tmp instance_.load(std::memory_order_relaxed); if (tmp nullptr) { tmp new MemoryModelSingleton(); instance_.store(tmp, std::memory_order_release); } } return *tmp; } private: static std::atomicMemoryModelSingleton* instance_; static std::mutex mutex_; };防止指令重排序确保单例初始化完成前指针不会被设置class ReorderingSafeSingleton { public: static ReorderingSafeSingleton getInstance() { static ReorderingSafeSingleton* instance new ReorderingSafeSingleton(); std::atomic_thread_fence(std::memory_order_acquire); return *instance; } private: ReorderingSafeSingleton() { // 初始化操作 std::atomic_thread_fence(std::memory_order_release); } };缓存一致性考虑高频访问的单例成员要考虑缓存行对齐class CacheFriendlySingleton { public: static CacheFriendlySingleton getInstance() { static CacheFriendlySingleton instance; return instance; } struct alignas(64) Counter { std::atomicint value{0}; }; Counter getCounter() { thread_local Counter counter; return counter; } private: // 其他成员... };19. 单例在分布式系统中的变体在分布式系统中传统的单例模式需要扩展集群单例使用分布式锁确保整个集群只有一个活跃实例class ClusterSingleton { public: static ClusterSingleton getInstance() { static ClusterSingleton instance; return instance; } bool tryAcquireLeadership() { // 尝试获取分布式锁 return distributedLock_.tryLock(); } void releaseLeadership() { distributedLock_.unlock(); } private: DistributedLock distributedLock_; };分片单例每个分片有自己的单例实例class ShardedSingleton { public: static ShardedSingleton getInstance(ShardID shard) { static std::arrayShardedSingleton, kNumShards instances; return instances[shard]; } private: // 分片特定数据 };租约机制通过租约实现有期限的单例class LeasedSingleton { public: static LeasedSingleton getInstance() { static LeasedSingleton instance; return instance; } bool acquireLease(std::chrono::milliseconds duration) { auto now std::chrono::steady_clock::now(); if (leaseExpiry_ now) return false; leaseExpiry_ now duration; return true; } private: std::chrono::steady_clock::time_point leaseExpiry_; };20. 单例模式的现代C最佳实践结合现代C特性总结单例模式的最佳实践使用std::optional替代指针更清晰地表达可能有值的语义class OptionalSingleton { public: static OptionalSingleton getInstance() { static std::optionalOptionalSingleton instance; if (!instance) { instance.emplace(); } return *instance; } private: OptionalSingleton() default; };结合RAII管理资源确保单例持有的资源正确释放class ResourceHoldingSingleton { public: static ResourceHoldingSingleton getInstance() { static ResourceHoldingSingleton instance; return instance; } ~ResourceHoldingSingleton() { releaseResources(); } private: ResourceHoldingSingleton() { initializeResources(); } void initializeResources() { /* ... */ } void releaseResources() { /* ... */ } };使用std::call_once确保一次性初始化比双重检查锁定更简洁安全class CallOnceSingleton { public: static CallOnceSingleton getInstance() { std::call_once(initFlag_, []() { instance_.emplace(); }); return *instance_; } private: static std::optionalCallOnceSingleton instance_; static std::once_flag initFlag_; };考虑使用依赖注入框架对于复杂项目使用专业DI容器管理单例生命周期// 使用Boost.DI示例 auto injector boost::di::make_injector( boost::di::bindIService.toServiceImpl().in(boost::di::singleton) ); auto service injector.createIService();21. 单例模式的可测试性改进为了提高单例模式的可测试性可以采用以下策略基于策略的单例将单例行为抽象为可替换的策略templatetypename CreationPolicy DefaultCreationPolicy class TestableSingleton { public: static TestableSingleton getInstance() { static TestableSingleton instance CreationPolicy::create(); return instance; } private: TestableSingleton() default; friend CreationPolicy; }; struct DefaultCreationPolicy { static TestableSingleton create() { return TestableSingleton(); } }; struct TestCreationPolicy { static TestableSingleton create() { auto instance TestableSingleton(); // 测试特定的初始化 return instance; } };环境上下文模式通过环境上下文获取单例测试时可替换class Environment { public: virtual Database getDatabase() 0; virtual ~Environment() default; }; class ProductionEnvironment : public Environment { Database getDatabase() override { return Database::getInstance(); } }; class TestEnvironment : public Environment { Database getDatabase() override { return testDatabase_; } private: TestDatabase testDatabase_; };单例注册表集中管理单例实例便于测试时替换class SingletonRegistry { public: templatetypename T static void registerInstance(std::unique_ptrT instance) { std::lock_guardstd::mutex lock(mutex_); instances_[typeid(T).name()] std::move(instance); } templatetypename T static T getInstance() { std::lock_guardstd::mutex lock(mutex_); auto it instances_.find(typeid(T).name()); if (it ! instances_.end()) { return *static_castT*(it-second.get()); } auto instance std::make_uniqueT(); auto ref *instance; instances_[typeid(T).name()] std::move(instance); return ref; } private: static std::unordered_mapstd::string, std::unique_ptrvoid instances_; static std::mutex mutex_; };22. 单例在插件架构中的应用在插件系统中单例模式需要特殊处理插件注册单例插件向核心系统注册单例服务class PluginServiceRegistry : public SingletonPluginServiceRegistry { public: void registerService(const std::string name, std::unique_ptrService service) { std::lock_guardstd::mutex lock(mutex_); services_[name] std::move(service); } Service* getService(const std::string name) const { std::lock_guardstd::mutex lock(mutex_); auto it services_.find(name); return it ! services_.end() ? it-second.get() : nullptr; } private: std::unordered_mapstd::string, std::unique_ptrService services_; mutable std::mutex mutex_; };跨DLL单例管理解决Windows平台DLL边界单例问题// 核心头文件 class CORE_API SingletonBase { protected: static void* getInstance(const char* name, std::functionvoid*() creator); }; templatetypename T class CrossDllSingleton : public SingletonBase { public: static T getInstance() { static T* instance static_castT*( getInstance(typeid(T).name(), []() { return new T(); })); return *instance; } };插件隔离单例每个插件有自己的单例实例class PluginSingleton { public: static PluginSingleton getInstance() { static std::unordered_mapstd::string, PluginSingleton instances; auto pluginName getCurrentPluginName(); return instances[pluginName]; } private: static std::string getCurrentPluginName() { // 获取当前插件名称 } };23. 单例模式的替代方案比较当单例模式不适用时考虑这些替代方案上下文对象通过调用链传递共享状态class RequestContext { public: Database getDatabase() { return db_; } Logger getLogger() { return logger_; } private: Database db_; Logger logger_; }; void processRequest(RequestContext ctx) { ctx.getLogger().log(Processing started); ctx.getDatabase().query(...); }服务定位器显式获取服务实例class ServiceLocator { public: static void registerService(std::type_index type, std::shared_ptrvoid service) { services_[type] std::move(service); } templatetypename T static T getService() { auto it services_.find(std::type_index(typeid(T))); if (it services_.end()) { throw std::runtime_error(Service not registered); } return *static_castT*(it-second.get()); } private: static std::unordered_mapstd::type_index, std::shared_ptrvoid services_; };依赖注入通过构造函数注入依赖class Client { public: explicit Client(std::shared_ptrService service) : service_(std::move(service)) {} void doWork() { service_-execute(); } private: std::shared_ptrService service_; };静态类对于无状态工具类class MathUtils { public: static double calculate(double input) { return input * 42.0; } MathUtils() delete; // 禁止实例化 };24. 单例模式在微服务架构中的演变在微服务架构下单例概念有了新的变化服务网格Sidecar模式每个服务实例有自己单例的sidecar代理class SidecarProxy { public: static SidecarProxy getInstance() { thread_local SidecarProxy instance; return instance; } void interceptRequest(Request req) { // 添加追踪头、认证等 } private: SidecarProxy() { // 初始化与服务网格控制面的连接 } };分布式配置中心全局配置作为逻辑单例物理上分布式存储class ConfigClient { public: static ConfigClient getInstance() { static ConfigClient instance; return instance; } std::string get(const std::string key) { std::lock_guardstd::mutex lock(cacheMutex_); if (cache_.count(key)) { return cache_[key]; } return fetchFromServer(key); } private: std::unordered_mapstd::string, std::string cache_; std::mutex cacheMutex_; };**服务