撮合引擎优化 - 延迟与吞吐

交易所在极端行情下会面临巨大的性能挑战。当热门币种价格剧烈波动时，瞬时订单量可能从正常的数千QPS飙升到数十万QPS。如果撮合引擎性能不足，会导致订单处理延迟大幅增加，影响用户体验。

本章介绍如何将撮合引擎从5万QPS优化到20万QPS，P99延迟从200ms降到5ms以下的优化方法。

1. 性能瓶颈分析

1.1 延迟来源分析

在深入优化之前，首先要定位延迟到底出现在哪里。

package engine

import (
	"sync"
	"sync/atomic"
	"time"
)

// 延迟监控器
type LatencyMonitor struct {
	// 各阶段耗时统计
	receiveTime   int64 // 接收订单时间
	validateTime  int64 // 验证订单耗时
	matchTime     int64 // 撮合计算耗时
	persistTime   int64 // 持久化耗时
	notifyTime    int64 // 通知耗时

	// 分位数统计
	p50, p90, p99, p999 time.Duration

	mu sync.RWMutex
	samples []time.Duration
}

// 追踪订单处理的各个阶段
type OrderTrace struct {
	OrderID      string
	ReceiveTime  time.Time
	ValidateTime time.Time
	MatchTime    time.Time
	PersistTime  time.Time
	NotifyTime   time.Time
}

func (t *OrderTrace) GetTotalLatency() time.Duration {
	return t.NotifyTime.Sub(t.ReceiveTime)
}

func (t *OrderTrace) GetBreakdown() map[string]time.Duration {
	return map[string]time.Duration{
		"validate": t.ValidateTime.Sub(t.ReceiveTime),
		"match":    t.MatchTime.Sub(t.ValidateTime),
		"persist":  t.PersistTime.Sub(t.MatchTime),
		"notify":   t.NotifyTime.Sub(t.PersistTime),
	}
}

// 实际测试中的延迟数据（优化前）
// ReceiveTime: 0ms
// ValidateTime: 5-10ms   (账户余额查询、风控检查)
// MatchTime: 50-150ms    (订单簿遍历、成交计算) ← 主要瓶颈
// PersistTime: 20-80ms   (数据库写入) ← 次要瓶颈
// NotifyTime: 10-30ms    (WebSocket推送)
// Total: 85-270ms

从上面的数据可以看出，撮合计算和持久化是两个主要瓶颈。

1.2 CPU Profile分析

# 开启Go pprof
import _ "net/http/pprof"

go func() {
    log.Println(http.ListenAndServe("localhost:6060", nil))
}()

# 抓取CPU profile
curl http://localhost:6060/debug/pprof/profile?seconds=30 > cpu.prof

# 分析
go tool pprof -http=:8080 cpu.prof

分析结果显示：

40% CPU消耗在订单簿的遍历查找
25% CPU消耗在锁竞争（sync.Mutex）
15% CPU消耗在内存分配（GC压力）
10% CPU消耗在序列化反序列化
10% 其他

2. Lock-Free优化

2.1 无锁订单队列

传统方案使用 sync.Mutex 保护共享数据，在高并发下会导致严重的锁竞争。

// 优化前：基于互斥锁的订单队列
type OrderQueue struct {
	mu     sync.Mutex
	orders []*Order
}

func (q *OrderQueue) Push(order *Order) {
	q.mu.Lock()
	defer q.mu.Unlock()
	q.orders = append(q.orders, order)
}

// 在10万QPS下，锁等待时间占总耗时的30%+

使用无锁队列替代：

// 优化后：基于CAS的无锁队列
type LockFreeQueue struct {
	head unsafe.Pointer // *node
	tail unsafe.Pointer // *node
}

type node struct {
	value *Order
	next  unsafe.Pointer // *node
}

func NewLockFreeQueue() *LockFreeQueue {
	n := unsafe.Pointer(&node{})
	return &LockFreeQueue{head: n, tail: n}
}

func (q *LockFreeQueue) Enqueue(order *Order) {
	n := &node{value: order}
	for {
		tail := load(&q.tail)
		next := load(&tail.next)
		if tail == load(&q.tail) { // 确保tail未被修改
			if next == nil {
				// 尝试将新节点链接到tail后面
				if cas(&tail.next, next, n) {
					// 成功后尝试更新tail指针
					cas(&q.tail, tail, n)
					return
				}
			} else {
				// tail已落后，帮助推进
				cas(&q.tail, tail, next)
			}
		}
	}
}

func (q *LockFreeQueue) Dequeue() *Order {
	for {
		head := load(&q.head)
		tail := load(&q.tail)
		next := load(&head.next)

		if head == load(&q.head) {
			if head == tail {
				if next == nil {
					return nil // 队列为空
				}
				cas(&q.tail, tail, next)
			} else {
				value := next.value
				if cas(&q.head, head, next) {
					return value
				}
			}
		}
	}
}

// 辅助函数
func load(p *unsafe.Pointer) *node {
	return (*node)(atomic.LoadPointer(p))
}

func cas(p *unsafe.Pointer, old, new *node) bool {
	return atomic.CompareAndSwapPointer(p, unsafe.Pointer(old), unsafe.Pointer(new))
}

性能对比：

BenchmarkMutexQueue-8        1000000    1523 ns/op
BenchmarkLockFreeQueue-8     5000000     312 ns/op

提升：4.88倍

2.2 读写分离的订单簿

对于订单簿，可以采用双缓冲技术实现读写分离。

type OrderBookDoubleBuffer struct {
	// 双缓冲
	active   *OrderBookSnapshot
	standby  *OrderBookSnapshot

	// 原子切换标志
	activeIndex int32 // 0 or 1

	// 写入通道
	updateChan chan *OrderUpdate
}

type OrderBookSnapshot struct {
	Bids *SkipList // 买盘快照
	Asks *SkipList // 卖盘快照
	Version int64  // 版本号
}

type OrderUpdate struct {
	OrderID   string
	Action    string // "add", "cancel", "fill"
	Order     *Order
	Timestamp time.Time
}

func NewOrderBookDoubleBuffer() *OrderBookDoubleBuffer {
	return &OrderBookDoubleBuffer{
		active:     &OrderBookSnapshot{Bids: NewSkipList(), Asks: NewSkipList()},
		standby:    &OrderBookSnapshot{Bids: NewSkipList(), Asks: NewSkipList()},
		updateChan: make(chan *OrderUpdate, 10000),
	}
}

// 读线程：无锁读取
func (ob *OrderBookDoubleBuffer) GetSnapshot() *OrderBookSnapshot {
	index := atomic.LoadInt32(&ob.activeIndex)
	if index == 0 {
		return ob.active
	}
	return ob.standby
}

// 写线程：在standby上修改，然后原子切换
func (ob *OrderBookDoubleBuffer) ApplyUpdate(update *OrderUpdate) {
	// 1. 在standby上应用更新
	standby := ob.getStandbyBuffer()

	switch update.Action {
	case "add":
		if update.Order.Side == Buy {
			standby.Bids.Insert(update.Order.Price, update.Order)
		} else {
			standby.Asks.Insert(update.Order.Price, update.Order)
		}
	case "cancel":
		if update.Order.Side == Buy {
			standby.Bids.Delete(update.Order.Price, update.Order.OrderID)
		} else {
			standby.Asks.Delete(update.Order.Price, update.Order.OrderID)
		}
	}

	standby.Version++

	// 2. 原子切换active和standby
	atomic.StoreInt32(&ob.activeIndex, 1-atomic.LoadInt32(&ob.activeIndex))

	// 3. 同步active到standby（准备下次更新）
	ob.syncBuffers()
}

func (ob *OrderBookDoubleBuffer) getStandbyBuffer() *OrderBookSnapshot {
	index := atomic.LoadInt32(&ob.activeIndex)
	if index == 0 {
		return ob.standby
	}
	return ob.active
}

func (ob *OrderBookDoubleBuffer) syncBuffers() {
	active := ob.GetSnapshot()
	standby := ob.getStandbyBuffer()

	// 深拷贝active到standby
	standby.Bids = active.Bids.Clone()
	standby.Asks = active.Asks.Clone()
	standby.Version = active.Version
}

这样做的好处：

读操作完全无锁，不会被写操作阻塞
写操作在standby上进行，不影响正在进行的读操作
切换开销极小，只是一个原子整数的修改

3. 内存优化

3.1 对象池优化

性能分析显示，每秒有大量的Order、Trade对象被创建和销毁，给GC带来巨大压力。

var (
	orderPool = sync.Pool{
		New: func() interface{} {
			return &Order{}
		},
	}

	tradePool = sync.Pool{
		New: func() interface{} {
			return &Trade{}
		},
	}
)

// 获取对象
func AcquireOrder() *Order {
	return orderPool.Get().(*Order)
}

// 归还对象
func ReleaseOrder(order *Order) {
	// 重置对象状态
	order.OrderID = ""
	order.UserID = ""
	order.Symbol = ""
	order.Price = 0
	order.Quantity = 0
	order.FilledQuantity = 0
	order.Status = 0

	orderPool.Put(order)
}

func AcquireTrade() *Trade {
	return tradePool.Get().(*Trade)
}

func ReleaseTrade(trade *Trade) {
	trade.TradeID = ""
	trade.BuyOrderID = ""
	trade.SellOrderID = ""
	trade.Price = 0
	trade.Quantity = 0

	tradePool.Put(trade)
}

使用示例：

func (e *MatchEngine) ProcessOrder(orderData *OrderRequest) []*Trade {
	// 从对象池获取
	order := AcquireOrder()
	defer ReleaseOrder(order) // 用完归还

	// 填充数据
	order.OrderID = orderData.OrderID
	order.UserID = orderData.UserID
	order.Symbol = orderData.Symbol
	order.Price = orderData.Price
	order.Quantity = orderData.Quantity

	// 撮合
	trades := e.match(order)

	return trades
}

性能提升：

优化前：
GC次数：150次/秒
GC暂停时间：P99 = 45ms

优化后：
GC次数：20次/秒
GC暂停时间：P99 = 8ms

内存分配减少：70%

3.2 预分配切片

// 优化前
func (e *MatchEngine) matchLimitOrder(order *Order) []*Trade {
	trades := make([]*Trade, 0) // 每次都从0开始分配

	// ... 撮合逻辑

	return trades
}

// 优化后
func (e *MatchEngine) matchLimitOrder(order *Order) []*Trade {
	// 根据历史数据，90%的订单产生的成交数 < 10
	trades := make([]*Trade, 0, 10) // 预分配容量

	// ... 撮合逻辑

	return trades
}

3.3 字符串优化

订单ID、交易ID等字符串频繁拼接会产生大量临时对象。

// 优化前
func generateTradeID(buyOrderID, sellOrderID string) string {
	return "T-" + buyOrderID + "-" + sellOrderID // 每次都创建新字符串
}

// 优化后
var tradeIDBuilder = sync.Pool{
	New: func() interface{} {
		return &strings.Builder{}
	},
}

func generateTradeID(buyOrderID, sellOrderID string) string {
	builder := tradeIDBuilder.Get().(*strings.Builder)
	defer func() {
		builder.Reset()
		tradeIDBuilder.Put(builder)
	}()

	builder.WriteString("T-")
	builder.WriteString(buyOrderID)
	builder.WriteString("-")
	builder.WriteString(sellOrderID)

	return builder.String()
}

4. 批量处理

4.1 订单批量撮合

与其每来一个订单就处理一次，不如积累一小批订单统一处理。

type BatchMatchEngine struct {
	engine      *MatchEngine
	batchSize   int
	batchBuffer []*Order
	bufferMu    sync.Mutex

	flushInterval time.Duration
	lastFlush     time.Time
}

func NewBatchMatchEngine(batchSize int, flushInterval time.Duration) *BatchMatchEngine {
	return &BatchMatchEngine{
		engine:        NewMatchEngine(),
		batchSize:     batchSize,
		batchBuffer:   make([]*Order, 0, batchSize),
		flushInterval: flushInterval,
		lastFlush:     time.Now(),
	}
}

func (b *BatchMatchEngine) AddOrder(order *Order) {
	b.bufferMu.Lock()
	b.batchBuffer = append(b.batchBuffer, order)
	shouldFlush := len(b.batchBuffer) >= b.batchSize ||
	              time.Since(b.lastFlush) > b.flushInterval
	b.bufferMu.Unlock()

	if shouldFlush {
		b.Flush()
	}
}

func (b *BatchMatchEngine) Flush() {
	b.bufferMu.Lock()
	if len(b.batchBuffer) == 0 {
		b.bufferMu.Unlock()
		return
	}

	// 取出当前批次
	batch := b.batchBuffer
	b.batchBuffer = make([]*Order, 0, b.batchSize)
	b.lastFlush = time.Now()
	b.bufferMu.Unlock()

	// 批量处理
	allTrades := make([]*Trade, 0, len(batch)*2)
	for _, order := range batch {
		trades := b.engine.ProcessOrder(order)
		allTrades = append(allTrades, trades...)
	}

	// 批量持久化
	b.batchPersist(allTrades)

	// 批量通知
	b.batchNotify(allTrades)
}

func (b *BatchMatchEngine) batchPersist(trades []*Trade) {
	// 使用数据库批量插入，减少网络往返
	// INSERT INTO trades VALUES (...), (...), (...)
}

func (b *BatchMatchEngine) batchNotify(trades []*Trade) {
	// 合并相同用户的通知，减少WebSocket消息数
	userTrades := make(map[string][]*Trade)
	for _, trade := range trades {
		userTrades[trade.BuyUserID] = append(userTrades[trade.BuyUserID], trade)
		userTrades[trade.SellUserID] = append(userTrades[trade.SellUserID], trade)
	}

	for userID, trades := range userTrades {
		notifyUser(userID, trades) // 一次发送多个成交
	}
}

效果：

数据库写入次数减少：95%
WebSocket推送次数减少：80%
整体吞吐量提升：3倍

4.2 动态批处理大小

根据实时负载动态调整批处理大小。

type AdaptiveBatchEngine struct {
	*BatchMatchEngine

	// 自适应参数
	minBatchSize int
	maxBatchSize int
	currentSize  int32

	// 性能监控
	avgLatency   time.Duration
	targetLatency time.Duration
}

func (a *AdaptiveBatchEngine) adjustBatchSize() {
	currentSize := atomic.LoadInt32(&a.currentSize)

	if a.avgLatency > a.targetLatency {
		// 延迟过高，减小批次
		newSize := int32(float64(currentSize) * 0.8)
		if newSize < int32(a.minBatchSize) {
			newSize = int32(a.minBatchSize)
		}
		atomic.StoreInt32(&a.currentSize, newSize)
	} else if a.avgLatency < a.targetLatency/2 {
		// 延迟很低，增大批次提高吞吐
		newSize := int32(float64(currentSize) * 1.2)
		if newSize > int32(a.maxBatchSize) {
			newSize = int32(a.maxBatchSize)
		}
		atomic.StoreInt32(&a.currentSize, newSize)
	}
}

// 后台协程定期调整
func (a *AdaptiveBatchEngine) AutoTune() {
	ticker := time.NewTicker(time.Second)
	defer ticker.Stop()

	for range ticker.C {
		a.adjustBatchSize()
	}
}

5. 并行化

5.1 多交易对并行撮合

不同交易对（如BTC/USDT、ETH/USDT）的订单完全独立，可以并行处理。

type MultiSymbolEngine struct {
	engines map[string]*MatchEngine // symbol -> engine
	mu      sync.RWMutex
}

func NewMultiSymbolEngine() *MultiSymbolEngine {
	return &MultiSymbolEngine{
		engines: make(map[string]*MatchEngine),
	}
}

func (m *MultiSymbolEngine) GetEngine(symbol string) *MatchEngine {
	m.mu.RLock()
	engine, exists := m.engines[symbol]
	m.mu.RUnlock()

	if !exists {
		m.mu.Lock()
		// Double-check
		engine, exists = m.engines[symbol]
		if !exists {
			engine = NewMatchEngine()
			m.engines[symbol] = engine
		}
		m.mu.Unlock()
	}

	return engine
}

func (m *MultiSymbolEngine) ProcessOrder(order *Order) []*Trade {
	// 根据交易对路由到对应引擎
	engine := m.GetEngine(order.Symbol)
	return engine.ProcessOrder(order)
}

// 并发处理多个交易对的订单
func (m *MultiSymbolEngine) ProcessOrdersConcurrently(orders []*Order) {
	// 按交易对分组
	symbolOrders := make(map[string][]*Order)
	for _, order := range orders {
		symbolOrders[order.Symbol] = append(symbolOrders[order.Symbol], order)
	}

	// 并行处理每个交易对
	var wg sync.WaitGroup
	for symbol, orders := range symbolOrders {
		wg.Add(1)
		go func(symbol string, orders []*Order) {
			defer wg.Done()
			engine := m.GetEngine(symbol)
			for _, order := range orders {
				engine.ProcessOrder(order)
			}
		}(symbol, orders)
	}

	wg.Wait()
}

5.2 Pipeline模式

将订单处理拆分成多个阶段，每个阶段由独立的goroutine处理。

type PipelineEngine struct {
	// Stage 1: 接收订单
	receiveChan chan *Order

	// Stage 2: 验证订单
	validateChan chan *Order

	// Stage 3: 撮合订单
	matchChan chan *Order

	// Stage 4: 持久化
	persistChan chan *Trade

	// Stage 5: 通知
	notifyChan chan *Trade
}

func NewPipelineEngine() *PipelineEngine {
	p := &PipelineEngine{
		receiveChan:  make(chan *Order, 1000),
		validateChan: make(chan *Order, 1000),
		matchChan:    make(chan *Order, 1000),
		persistChan:  make(chan *Trade, 5000),
		notifyChan:   make(chan *Trade, 5000),
	}

	// 启动各个阶段
	go p.receiveStage()
	go p.validateStage()
	go p.matchStage()
	go p.persistStage()
	go p.notifyStage()

	return p
}

func (p *PipelineEngine) receiveStage() {
	for order := range p.receiveChan {
		// 做一些预处理
		order.ReceiveTime = time.Now()

		// 传递到下一阶段
		p.validateChan <- order
	}
}

func (p *PipelineEngine) validateStage() {
	for order := range p.validateChan {
		// 验证订单
		if err := validateOrder(order); err != nil {
			log.Printf("Invalid order: %v", err)
			continue
		}

		order.ValidateTime = time.Now()
		p.matchChan <- order
	}
}

func (p *PipelineEngine) matchStage() {
	engine := NewMatchEngine()
	for order := range p.matchChan {
		// 撮合
		trades := engine.ProcessOrder(order)

		// 将所有成交传递到持久化阶段
		for _, trade := range trades {
			p.persistChan <- trade
		}
	}
}

func (p *PipelineEngine) persistStage() {
	batch := make([]*Trade, 0, 100)
	ticker := time.NewTicker(10 * time.Millisecond)
	defer ticker.Stop()

	for {
		select {
		case trade := <-p.persistChan:
			batch = append(batch, trade)
			if len(batch) >= 100 {
				p.flushBatch(batch)
				batch = make([]*Trade, 0, 100)
			}
		case <-ticker.C:
			if len(batch) > 0 {
				p.flushBatch(batch)
				batch = make([]*Trade, 0, 100)
			}
		}
	}
}

func (p *PipelineEngine) flushBatch(trades []*Trade) {
	// 批量写入数据库
	db.BatchInsertTrades(trades)

	// 传递到通知阶段
	for _, trade := range trades {
		p.notifyChan <- trade
	}
}

func (p *PipelineEngine) notifyStage() {
	for trade := range p.notifyChan {
		// 推送通知
		notifyUsers(trade)
	}
}

// 提交订单
func (p *PipelineEngine) SubmitOrder(order *Order) {
	p.receiveChan <- order
}

这种Pipeline模式的优势：

各阶段解耦，互不阻塞
易于扩展，可以为某个阶段启动多个worker
背压控制，通过channel缓冲区大小控制流量

6. 性能测试与监控

6.1 压力测试

func BenchmarkMatchEngine(b *testing.B) {
	engine := NewMatchEngine()

	// 预热：建立初始订单簿
	for i := 0; i < 1000; i++ {
		price := 10000.0 + float64(i)
		engine.ProcessOrder(&Order{
			OrderID:  fmt.Sprintf("buy-%d", i),
			Side:     Buy,
			Price:    price,
			Quantity: 1.0,
			Type:     Limit,
		})
		engine.ProcessOrder(&Order{
			OrderID:  fmt.Sprintf("sell-%d", i),
			Side:     Sell,
			Price:    price + 100,
			Quantity: 1.0,
			Type:     Limit,
		})
	}

	b.ResetTimer()
	b.RunParallel(func(pb *testing.PB) {
		i := 0
		for pb.Next() {
			order := &Order{
				OrderID:  fmt.Sprintf("order-%d", i),
				Side:     Buy,
				Price:    10500.0,
				Quantity: 0.1,
				Type:     Limit,
			}
			engine.ProcessOrder(order)
			i++
		}
	})
}

// 结果
// BenchmarkMatchEngine-8    200000    5234 ns/op    191 QPS

6.2 实时监控

type EngineMetrics struct {
	// 吞吐量
	OrdersProcessed  uint64
	TradesGenerated  uint64

	// 延迟
	LatencyP50  time.Duration
	LatencyP90  time.Duration
	LatencyP99  time.Duration
	LatencyP999 time.Duration

	// 订单簿深度
	BidDepth int
	AskDepth int

	// 资源使用
	GoroutineCount int
	MemoryUsage    uint64
	CPUUsage       float64

	mu sync.RWMutex
	latencySamples []time.Duration
}

func (m *EngineMetrics) RecordLatency(latency time.Duration) {
	m.mu.Lock()
	m.latencySamples = append(m.latencySamples, latency)

	// 每1000个样本计算一次分位数
	if len(m.latencySamples) >= 1000 {
		m.calculatePercentiles()
		m.latencySamples = m.latencySamples[:0]
	}
	m.mu.Unlock()
}

func (m *EngineMetrics) calculatePercentiles() {
	samples := make([]time.Duration, len(m.latencySamples))
	copy(samples, m.latencySamples)

	sort.Slice(samples, func(i, j int) bool {
		return samples[i] < samples[j]
	})

	m.LatencyP50 = samples[len(samples)*50/100]
	m.LatencyP90 = samples[len(samples)*90/100]
	m.LatencyP99 = samples[len(samples)*99/100]
	m.LatencyP999 = samples[len(samples)*999/1000]
}

// Prometheus导出
func (m *EngineMetrics) ExportPrometheus() string {
	return fmt.Sprintf(`
# HELP match_engine_orders_total Total orders processed
# TYPE match_engine_orders_total counter
match_engine_orders_total %d

# HELP match_engine_trades_total Total trades generated
# TYPE match_engine_trades_total counter
match_engine_trades_total %d

# HELP match_engine_latency_seconds Order processing latency
# TYPE match_engine_latency_seconds summary
match_engine_latency_seconds{quantile="0.5"} %f
match_engine_latency_seconds{quantile="0.9"} %f
match_engine_latency_seconds{quantile="0.99"} %f
match_engine_latency_seconds{quantile="0.999"} %f
`,
		atomic.LoadUint64(&m.OrdersProcessed),
		atomic.LoadUint64(&m.TradesGenerated),
		m.LatencyP50.Seconds(),
		m.LatencyP90.Seconds(),
		m.LatencyP99.Seconds(),
		m.LatencyP999.Seconds(),
	)
}

7. 优化效果总结

经过上述优化后，撮合引擎性能可以实现质的飞跃：

指标	优化前	优化后	提升
吞吐量 (QPS)	5万	20万	4倍
P99延迟	200ms	5ms	40倍
P999延迟	500ms	15ms	33倍
CPU使用率	85%	60%	-29%
内存分配	1.2GB/s	350MB/s	-71%
GC暂停	45ms	8ms	-82%

8. 实战经验

8.1 优化的优先级

先Profile，后优化：不要凭感觉优化，一定要用数据说话
抓大放小：优化占CPU 40%的模块，比优化占2%的模块收益大20倍
先算法，后技巧：O(n²) 优化到 O(n log n)，比任何微优化都有效

8.2 常见误区

误区1：过早优化

// 没必要
func add(a, b int) int {
	return a + b  // 想优化成汇编？
}

// 应该优化
func findOrder(orderID string) *Order {
	// 遍历10万个订单，这才是瓶颈
}

误区2：过度优化

// 为了避免一次内存分配，写出的代码
func uglyCode() {
	// 100行难以维护的代码
}

// 其实这一次分配的开销 < 1微秒，完全不值得

误区3：忽略IO瓶颈

// CPU优化到极致
func ultraFastMatch() { ... }

// 但数据库写入还是100ms，整体还是慢

9. 下一步优化方向

FPGA/GPU加速：将撮合算法卸载到硬件
RDMA网络：绕过内核，实现微秒级延迟
持久化内存：用Intel Optane等持久化内存代替数据库
分布式撮合：将订单簿分片到多台机器

小结

撮合引擎优化是一个系统工程，需要从算法、并发、内存、IO等多个维度综合考虑。核心思路：

Profile定位瓶颈
减少锁竞争
降低内存分配
批量处理
并行化
持续监控

下一章将讨论撮合引擎的高可用设计，包括主从复制、故障切换、数据恢复等内容。