撮合引擎开发:完结篇

原创文章,转载请注明:转载自Keegan小钢
并标明原文链接:http://keeganlee.me/post/matching/20191204
微信公众号:名称:Keegan小钢;微信号:keeganlee_me
写于2019-12-04


撮合引擎开发:开篇
撮合引擎开发:MVP版本
撮合引擎开发:数据结构设计
撮合引擎开发:对接黑箱
撮合引擎开发:解密黑箱流程
撮合引擎开发:流程的代码实现
撮合引擎开发:缓存和MQ
撮合引擎开发:日志输出
撮合引擎开发:完结篇


本小节是该系列文章的最后一篇了,将讲解剩下的一些东西,包括交易委托账本中订单队列的实现逻辑、更多订单类型的实现逻辑。另外,不少朋友在问,完结后所有代码是否会开源放上 Github?我只能说,长期大概率会开源,但短期内还没打算开源。

订单队列

交易委托账本其实就是由两个订单队列组成的,一个买单队列,一个卖单队列。任何对交易委托账本的查询和操作,实际上都是查询和操作这两个队列。订单队列的设计也直接影响了撮合的性能,前面文章讲数据结构设计时也有简单聊了订单队列的设计,我们主要是用二维链接结合 Map 来保存所有订单的,依赖的是 container/list 包。

订单队列的结构体如下:

1
2
3
4
5
type orderQueue struct {
sortBy enum.SortDirection
parentList *list.List
elementMap map[string]*list.Element
}

sortBy 指定价格排序的方向,买单队列是降序的,而卖单队列则是升序的。parentList 保存整个二维链表的所有订单,第一维以价格排序,第二维以时间排序。elementMap 则是 Key 为价格、Value 为第二维订单链表的键值对。

初始化函数就比较简单了,对几个字段赋值而已,代码如下:

1
2
3
4
5
func (q *orderQueue) init(sortBy enum.SortDirection) {
q.sortBy = sortBy
q.parentList = list.New()
q.elementMap = make(map[string]*list.Element)
}

除了初始化函数,还提供了另外五个函数:

  • addOrder(order):添加订单
  • getHeadOrder():读取头部订单
  • popHeadOrder():读取并删除头部订单
  • removeOrder(order):移除订单
  • getDepthPrice(depth):读取深度价格

以上五个函数就只有第一个函数会比较复杂,为了让处理流程更容易理解,我就不贴代码了,画一个完整的流程图给大家看看:

这个流程确实有一点复杂,可以多看几遍好好消化,最好自己动手将其转为代码实现。

其他几个函数就简单了,关于最后一个函数需要补充说明一下。读取深度价格是为了方便处理 market-opponent、market-top5、market-top10 等类型的订单时判断上限价格。请看该函数的代码以理解该函数的逻辑和用法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
func (q *orderQueue) getDepthPrice(depth int) (string, int) {
if q.parentList.Len() == 0 {
return "", 0
}
p := q.parentList.Front()
i := 1
for ; i < depth; i++ {
t := p.Next()
if t != nil {
p = t
} else {
break;
}
}
o := p.Value.(*list.List).Front().Value.(*Order)
return o.Price.String(), i
}

多种订单类型

我们引擎总共支持了六种订单类型,之前的文章有简单介绍过,但没有深入讲解这几种不同类型的具体业务逻辑应该是怎样的,因此,在此将这部分内容补充上。

1. limit

普通限价是最简单的,前文也已经展示过代码实现,为了加深理解,我再给大家画一张图:

处理逻辑就是:

  1. 判断新订单是买单还是卖单。
  2. 如果是买单,那从 OrderBook 中读取出头部卖单,即卖单队列中的头部订单;如果是卖单,那从 OrderBook 中读取出头部买单,即买单队列中的头部订单。
  3. 新订单为买单时,如果头部订单为空,或者新订单小于头部订单,即无法成交,那就把新订单添加到买单队列中,处理结束;新订单为卖单时,如果头部订单为空,或者新订单大于头部订单,即无法成交,那就把新订单添加到卖单队列中,处理结束。
  4. 否则,符合匹配条件,新订单和头部订单进行撮合成交。
  5. 撮合完成后,如果新订单剩余数量为零则结束,如果还大于零,则回到第2步继续取下一个头部订单,如此循环。

2. limit-ioc

IOC 限价与普通限价不同的地方只有一个,如果新订单和头部订单不匹配时,普通限价单会被添加到订单队列中,而 IOC 限价则是作撤单处理,请看下图:

3. market

默认市价单的逻辑也比较简单,它不需要判断价格,只要头部订单不为空,就直接和头部订单匹配成交,其处理逻辑如下图:

4. market-top5/market-top10

最优五档/十档市价单与默认市价单的逻辑也是类似的,不同点在于:默认市价的成交价格没有上限或下限,但最优五档/十档市价则存在价格上限或下限,超过上下限的委托单不会成交。画图太累,还是直接贴代码吧,以下是处理买单的:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
func dealBuyMarketTop(order *Order, book *orderBook, lastTradePrice *decimal.Decimal, depth int) {
priceStr, _ := book.getSellDepthPrice(depth)
if priceStr == "" {
cancelOrder(order)
return
}
limitPrice, _ := decimal.NewFromString(priceStr)
LOOP:
headOrder := book.getHeadSellOrder()
if headOrder != nil && limitPrice.GreaterThanOrEqual(headOrder.Price) {
matchTrade(headOrder, order, book, lastTradePrice)
if order.Amount.IsPositive() {
goto LOOP
}
} else {
cancelOrder(order)
}
}

5. market-opponent

最后一种类型,对手方最优价,该类型只与对手方一档的价位成交,但与最优五档/十档还有一点不一样:最优五档/十档未成交的部分是作撤单处理的,而对手方最优价最后未成交的部分则是转为限价单。请看代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
func dealBuyMarketOpponent(order *Order, book *orderBook, lastTradePrice *decimal.Decimal) {
priceStr, _ := book.getSellDepthPrice(1)
if priceStr == "" {
cancelOrder(order)
return
}
limitPrice, _ := decimal.NewFromString(priceStr)
LOOP:
headOrder := book.getHeadSellOrder()
if headOrder != nil && limitPrice.GreaterThanOrEqual(headOrder.Price) {
matchTrade(headOrder, order, book, lastTradePrice)
if order.Amount.IsPositive() {
goto LOOP
}
} else {
order.Price = limitPrice
order.Type = enum.TypeLimit
book.addBuyOrder(order)
cache.UpdateOrder(order.ToMap())
log.Info("engine %s, a order has added to the orderbook: %s", order.Symbol, order.ToJson())
}
}

完结

至此,整个系列就此完结。不过,我的撮合程序依然会继续迭代升级,另外,也将开始开发其他组件,将会和当前这个撮合引擎结合来用。欢迎关注后续动态。


扫描以下二维码即可关注公众号(公众号名称:Keegan小钢)