订单簿核心原理与C++高性能实现详解

1. 订单簿（Order Book）基础概念解析

订单簿是金融交易系统中撮合引擎的核心组件，它负责维护所有未成交的限价订单（Limit Order）。在典型的交易所架构中，订单簿按照买卖方向分为两个独立部分：

• 买方簿（Bid Book）：存储所有买入限价订单，按价格从高到低排列
• 卖方簿（Ask Book）：存储所有卖出限价订单，按价格从低到高排列

每个价格档位（Price Level）上的订单遵循价格优先、时间优先的匹配规则：

1. 价格优先：更高买价和更低卖价优先成交
2. 时间优先：同一价格下，先到达的订单优先成交

关键术语解释：

• 最优买价（Best Bid）：买方簿中的最高价格
• 最优卖价（Best Ask）：卖方簿中的最低价格
• 买卖价差（Spread）：Best Ask - Best Bid
• 中间价（Mid Price）：(Best Bid + Best Ask) / 2

2. 核心数据结构设计与实现

2.1 订单（Order）结构体

订单是系统中最基本的原子单元，我们使用结构体表示：

cpp复制enum class Side { BUY, SELL };

struct Order {
    Side side_;
    uint64_t order_id_;
    int price_;          // 使用整数表示价格，避免浮点精度问题
    uint32_t quantity_;
    Order* prev_ = nullptr;
    Order* next_ = nullptr;
    
    Order() = default;
    Order(Side side, uint64_t order_id, int price, uint32_t quantity)
        : side_(side), order_id_(order_id), price_(price), quantity_(quantity) {}
};

设计要点：

1. 使用int而非double存储价格：实际交易系统中，价格通常表示为最小变动单位（如0.01元）的整数倍
2. prev_和next_指针：用于构建同一价格档位内的双向链表，实现FIFO语义
3. 明确的构造函数：确保订单对象初始状态确定

2.2 价格档位（Level）实现

每个价格档位管理同一价格上的所有订单：

cpp复制struct Level {
    Order* head_ = nullptr;
    Order* tail_ = nullptr;
    uint32_t total_quantity_ = 0;
    
    // 添加新订单到链表头部（最新订单）
    Order* AddOrder(Allocator& alloc, Side side, uint64_t order_id,
                   int price, uint32_t quantity) {
        Order* order = new (alloc.Allocate()) Order(side, order_id, price, quantity);
        if (!head_) {
            head_ = tail_ = order;
        } else {
            order->next_ = head_;
            head_->prev_ = order;
            head_ = order;
        }
        total_quantity_ += quantity;
        return order;
    }
    
    // 从链表中移除订单
    void RemoveOrder(Allocator& alloc, Order* order) {
        if (order == head_) head_ = head_->next_;
        if (order == tail_) tail_ = tail_->prev_;
        if (order->prev_) order->prev_->next_ = order->next_;
        if (order->next_) order->next_->prev_ = order->prev_;
        total_quantity_ -= order->quantity_;
        alloc.Deallocate(order);
    }
};

关键细节：

1. 新订单插入链表头部，保证时间顺序
2. 移除订单时需要处理四种边界情况：
   • 订单是头节点
   • 订单是尾节点
   • 订单有前驱节点
   • 订单有后继节点
3. 维护total_quantity_确保快速查询档位总量

2.3 高性能内存分配器

标准new/delete在高频交易场景性能不足，我们实现专用内存池：

cpp复制struct Allocator {
private:
    std::vector<Order*> pools_;
    Order* free_head_ = nullptr;
    size_t chunksize_ = 16;
    
    void Extend() {
        free_head_ = static_cast<Order*>(::operator new(chunksize_ * sizeof(Order)));
        pools_.push_back(free_head_);
        // 构建空闲链表
        for (size_t i = 0; i < chunksize_; i++) {
            free_head_[i].next_ = (i + 1 < chunksize_) ? &free_head_[i+1] : nullptr;
        }
        chunksize_ = std::min(chunksize_ * 2, static_cast<size_t>(1 << 20));
    }

public:
    Order* Allocate() {
        if (!free_head_) Extend();
        Order* order = free_head_;
        free_head_ = free_head_->next_;
        return order;
    }
    
    void Deallocate(Order* order) {
        order->next_ = free_head_;
        free_head_ = order;
    }
    
    ~Allocator() {
        for (Order* p : pools_) ::operator delete(p);
    }
};

优化原理：

1. 预分配大块内存，减少系统调用
2. 空闲链表实现O(1)分配/释放
3. 块大小指数增长，平衡内存使用和扩展频率
4. 禁止拷贝构造，避免意外共享

3. 订单簿核心逻辑实现

3.1 订单簿类结构

cpp复制class OrderBook {
    Allocator allocator_;
    std::map<int, Level, std::greater<>> buy_book_;  // 买方簿，价格降序
    std::map<int, Level> sell_book_;                 // 卖方簿，价格升序
    std::unordered_map<uint64_t, Order*> order_map_; // OrderID到订单的映射
    
    // ... 其他