返回题库

原子 shared_ptr 配置

Atomic Shared Ptr Config

专题
Systems & Architecture / 系统与架构
难度
L2
来源
MyntBit

题目详情

在高并发金融系统中，风控限额和交易标志等配置必须动态更新而不在热路径引入延迟或抖动。利用原子操作管理共享指针提供了一种无锁机制来安全地在多线程间切换不可变配置对象。此模式确保延迟敏感的交易线程可以无等待地读取最新配置。

任务：实现 AtomicConfig 类，使用 std::atomic<std::shared_ptr> 存储配置对象。提供 load() 返回当前配置（无等待读取），store() 更新配置（原子替换）。

英文原题

In highly concurrent financial systems, configuration settings such as risk limits and trading flags must be updated dynamically without introducing latency or jitter on the hot path. Utilizing atomic operations on shared pointers provides a lock-free mechanism to manage immutable configuration objects safely across multiple threads. This pattern ensures that latency-sensitive trading threads can continuously read the active configuration without being blocked by background updates.
Task
Implem

解析

问题分析

交易系统的配置（如费率表、路由规则）需支持热加载——运行时更新而无服务中断。std::atomic<std::shared_ptr<T>> (C++20) 允许原子地替换配置对象的 shared_ptr，读者无锁获取最新配置。

实现

struct Config { double fee_bps; int max_order_qty; std::string venue; };
std::atomic<std::shared_ptr<Config>> g_config{std::make_shared<Config>()};

void reloadConfig(const Config& c) {
    g_config.store(std::make_shared<Config>(c), std::memory_order_release);
}
Config readConfig() {
    auto sp = g_config.load(std::memory_order_acquire);
    return *sp;  // 拷贝——shared_ptr 保证对象在读取期间不被释放
}

复杂度与边界

  • 时间复杂度：读取 O(1)（load 为原子操作）+ O(sizeof(Config)) 拷贝
  • 空间复杂度：O(1) 额外空间，旧配置在最后读者释放后自动回收
  • 边界条件：(1) 频繁热加载产生大量 Config 对象，内存持续增长 (2) 应使用轻量配置结构避免大拷贝 (3) 适合读多写极少场景

英文解析

Analysis

Trading system configurations (fee tables, routing rules) must support hot-reloading — runtime updates without service interruption. `std::atomic>` (C++20) allows atomically replacing the shared_ptr to a config object; readers obtain the latest configuration lock-free.

Solution

struct Config { double fee_bps; int max_order_qty; std::string venue; };
std::atomic<std::shared_ptr<Config>> g_config{std::make_shared<Config>()};

void reloadConfig(const Config& c) {
    g_config.store(std::make_shared<Config>(c), std::memory_order_release);
}
Config readConfig() {
    auto sp = g_config.load(std::memory_order_acquire);
    return *sp;  // copy — shared_ptr guarantees object not freed during read
}

Complexity & Edge Cases

  • Time complexity: Read O(1) (atomic load) + O(sizeof(Config)) copy
  • Space complexity: O(1) extra space; old config auto-reclaimed after last reader releases
  • Edge cases: (1) Frequent hot-reloads create many Config objects, memory grows continuously (2) Use lightweight config structs to avoid large copies (3) Best for read-heavy, write-rare scenarios

Key Considerations

  1. Lock-free guarantee: std::atomic<shared_ptr> is NOT lock-free on all platforms; check is_lock_free() before relying on it for low-latency paths
  2. ABA prevention: Atomic shared_ptr uses reference counting, not CAS on raw pointer — ABA problem is inherently prevented by control block lifetime
  3. Memory ordering: load() with acquire and store() with release provides correct visibility; relaxed ordering unsuitable for configuration data read by multiple threads
  4. Copy overhead: atomic<shared_ptr> copy increments control block refcount atomically; frequent copies in hot paths add overhead — cache the loaded value locally