只有两方参与，投资人和基金管理人，没有法人
组建法人，成立股东会，按公司运营
法律地位不同：公司型投资人是以股东形式存在，并可以行使股东权利，对投资可以有较大的干预权限，契约型的则是委托代为投资，没有太多对投资行为干预的权限
证券投资基金（特指公募基金）是将众多不特定的投资者资金汇集形成独立财产，委托基金管理人（发产品的人）投资管理，基金托管人进行财产托管
金融市场是资金货币融通的市场
市场分类：
交易工具期限分类：货币市场、资本市场
标的物分类：证券、票据、衍生物、外汇、黄金
交易交割期限分类：期货、现货
市场构成：
市场参与者：政府、中央银行、企业或个人居民、金融机构
金融工具：证明债权债务关系并据此进行货币资金交易的合法凭证
交易组织方式：固定场所集中式、柜台双方面议、电信网络交易
资产管理与资产管理行业
资产管理：受投资人委托，为达成投资人特定目标代理投资人对投资人资本进行管理，并以此收取服务费用
资产管理行业：基金管理公司、私募机构、信托公司、证券公司、期货公司、保险公司、商业银行
一个好的量化交易，是对于一个函数的极值的搜索及规则的搜索
但因为函数的复杂性，无法得到函数的性质，有时候可以采用暴力搜索极值点的方式
类似于sum(f(g(x,y),z),t) = alpha其中z是外部响应，z与g(x,y)之间接近线性无关（我们的交易量远达不到影响结果的情景）t是时间序列下标
g（x，y）中不同的系数对于f的的影响不同，又因为g(x,y)不是一个显函数，只能通过代入数据计算
我们定义每组(x,y,ts,te)为搜索任务，将数据及计算函数交由每个线程完成，此时不会涉及多线程问题，任务之间线性无关
第一版本我本想通过序列化为字符串形式来作为存储
但因为字符串是变长形式，难以在文件层级进行读写
故而想到如对象存储一般，因为实现难度高，工程量巨大（修改操作占主要），故转而投向SQLite作为持久化操作
我以SQL作为存储端，将任务分发至多台机器形成集群，可以极大的加快搜索进度，且任意机器死亡可以在另一台机器上恢复，无需从头开始
public class MarketPlace {
private Map<String, WriteLockMap<Long, OrderQueen>> sellOrderChannel;
private Map<String, WriteLockMap<Long, OrderQueen>> buyOrderChannel;
private Map<String, Long> lastComplete;
public MarketPlace() {
this.sellOrderChannel = new ConcurrentHashMap<>();
this.buyOrderChannel = new ConcurrentHashMap<>();
this.lastComplete = new ConcurrentHashMap<>();
}
public void order(Order order) {
OrderQueen orderQueen;
WriteLockMap<Long, OrderQueen> longOrderQueenMap;
String fixCacheString = order.getTradeCode().intern();
if (order.sell()) {
longOrderQueenMap = buyOrderChannel.get(order.getTradeCode());
if (longOrderQueenMap == null) {
synchronized (fixCacheString) {
longOrderQueenMap = new WriteLockMap<>(new ConcurrentHashMap<>());
buyOrderChannel.put(order.getTradeCode(), longOrderQueenMap);
}
}
} else {
longOrderQueenMap = sellOrderChannel.get(order.getTradeCode());
if (longOrderQueenMap == null) {
synchronized (fixCacheString) {
longOrderQueenMap = new WriteLockMap<>(new ConcurrentHashMap<>());
sellOrderChannel.put(order.getTradeCode(), longOrderQueenMap);
}
}
}
orderQueen = longOrderQueenMap.get(order.getPrice());
if (orderQueen == null) {
longOrderQueenMap.lock();
orderQueen = new OrderQueen(order.getPrice());
longOrderQueenMap.put(order.getPrice(), orderQueen);
longOrderQueenMap.unlock();
}
Long price = orderQueen.try2ClinchOrder(order);
if (price != null) {
this.lastComplete.put(order.getTradeCode(), price);
}
if (!order.isComplete()) {
if (order.sell()) {
WriteLockMap<Long, OrderQueen> tm = this.sellOrderChannel
.get(order.getTradeCode());
if (tm == null) {
synchronized (fixCacheString) {
WriteLockMap<Long, OrderQueen> writeLockMap = new WriteLockMap<>(
new ConcurrentHashMap<>());
OrderQueen newOne = new OrderQueen(order.getPrice());
newOne.addOrder(order);
writeLockMap.put(order.getPrice(), newOne);
this.sellOrderChannel.put(order.getTradeCode(), writeLockMap);
}
} else {
OrderQueen orderQueen1 = tm.get(order.getPrice());
if (orderQueen1 == null) {
tm.lock();
orderQueen1 = new OrderQueen(order.getPrice());
orderQueen1.addOrder(order);
tm.put(order.getPrice(), orderQueen1);
tm.unlock();
}
}
} else {
WriteLockMap<Long, OrderQueen> tm = this.buyOrderChannel
.get(order.getTradeCode());
if (tm == null) {
synchronized (fixCacheString) {
WriteLockMap<Long, OrderQueen> writeLockMap = new WriteLockMap<>(
new ConcurrentHashMap<>());
OrderQueen newOne = new OrderQueen(order.getPrice());
newOne.addOrder(order);
writeLockMap.put(order.getPrice(), newOne);
this.buyOrderChannel.put(order.getTradeCode(), writeLockMap);
}
} else {
OrderQueen orderQueen1 = tm.get(order.getPrice());
if (orderQueen1 == null) {
tm.lock();
orderQueen1 = new OrderQueen(order.getPrice());
orderQueen1.addOrder(order);
tm.put(order.getPrice(), orderQueen1);
tm.unlock();
} else {
orderQueen1.addOrder(order);
}
}
}
}
}
public Long getLastPrice(String security) {
return this.lastComplete.get(security);
}
}
public class OrderQueen {
//最近完成的订单位置
private int lastCompleteIndex;
private int lastInsertIndex;
private int lastInsertCacheIndex;
//归属价格级别
private long priceLevel;
//订单队列
private Order[] orders;
private Order[][] finishCache;
public OrderQueen(long priceLevel) {
this.priceLevel = priceLevel;
orders = new Order[5000];
finishCache = new Order[500][];
lastCompleteIndex = -1;
lastInsertIndex = 0;
}
private boolean needExpendOrderList() {
return orders.length <= lastInsertIndex;
}
private void expand() {
Order[] orders = new Order[5000];
this.finishCache[lastInsertCacheIndex] = this.orders;
lastInsertCacheIndex++;
this.orders = orders;
lastInsertIndex = 0;
lastCompleteIndex = -1;
}
public long getPriceLevel() {
return priceLevel;
}
public synchronized void addOrder(Order order) {
if (needExpendOrderList()) {
expand();
}
this.orders[lastInsertIndex] = order;
lastInsertIndex++;
}
public synchronized Long try2ClinchOrder(Order order2Clinch) {
Long clinchPrice = null;
for (int index = lastCompleteIndex + 1; index < lastInsertIndex; index++) {
Order order = this.orders[index];
long count;
try {
count = order2Clinch.getRemainCount() - order.getRemainCount();
} catch (NullPointerException e) {
throw new NullPointerException();
}
if (count < 0) {
long completeCount = order.getRemainCount() - Math.abs(count);
order2Clinch.addCompleteCount(completeCount);
order2Clinch.complete();
order.addCompleteCount(completeCount);
clinchPrice = order.getPrice();
break;
} else if (count == 0) {
order2Clinch.addCompleteCount(order.getRemainCount());
order2Clinch.complete();
order.addCompleteCount(order.getRemainCount());
order.complete();
clinchPrice = order.getPrice();
lastCompleteIndex++;
break;
} else {
order2Clinch.addCompleteCount(order.getRemainCount());
order.addCompleteCount(order.getRemainCount());
order.complete();
clinchPrice = order.getPrice();
lastCompleteIndex++;
}
}
return clinchPrice;
}
}
测试发现，50W的数据从原来的80000ms降低到100ms，效果显著，多线程测试亦无问题
public class MarketPlace {
private Map<String, List<Order>> orderChannel;
private Map<String, Long> lastComplete;
public MarketPlace() {
orderChannel = new ConcurrentHashMap<>();
lastComplete = new ConcurrentHashMap<>();
}
public void order(Order order) {
List<Order> list = orderChannel.get(order.getTradeCode());
if (Objects.isNull(list)) {
list = new ArrayList<>();
orderChannel.put(order.getTradeCode(), list);
}
synchronized (list) {
List<Order> targetPriceOrder;
List<Order> sellOrder = list.stream()
.filter(order1 -> !order1.isComplete())
.filter(Order::sell)
.sorted(Comparator.comparing(Order::getPrice)
.thenComparing(Order::getTimestamp))
.collect(Collectors.toList());
List<Order> buyOrder = list.stream()
.filter(order1 -> !order1.isComplete())
.filter(order1 -> !order1.sell())
.sorted(Comparator.comparing(Order::getPrice, Comparator.reverseOrder())
.thenComparing(Order::getTimestamp))
.collect(Collectors.toList());
//进来的是买单
if (!order.sell()) {
if (!buyOrder.isEmpty() && buyOrder.get(0).getPrice() > order.getPrice()) {
list.add(order);
return;
}
//处理好后，是按照价格小，时间先排列
targetPriceOrder = sellOrder.stream()
//需要找到挂单中比当前订单要价低或者相等的
.filter(order1 -> order.getPrice() <= order1.getPrice())
.collect(Collectors.toList());
} else {
if (!sellOrder.isEmpty() && sellOrder.get(0).getPrice() < order.getPrice()) {
list.add(order);
return;
}
//进来的是卖单,找买单 , 卖单进来，先开始撮合最高价的买单
targetPriceOrder = buyOrder.stream()
//需要找到买单中比当前订单要价高的
.filter(order1 -> order.getPrice() <= order1.getPrice())
.collect(Collectors.toList());
//新入订单需要撮合的数量
}
//新入订单需要撮合的数量
long count = order.getRemainCount();
//连续竞价,买单进来，开始先撮合最低价的卖单
for (Order order1 : targetPriceOrder) {
count = count - order1.getRemainCount();
if (count < 0) {
//说明当前订单已经满足，order不需要进入队列排队,order1更新成交数，中断循环
order1.addCompleteCount(order1.getCount() - Math.abs(count));
order.addCompleteCount(order.getCount());
order.complete();
this.lastComplete.put(order.getTradeCode(), order.getPrice());
break;
} else if (count == 0) {
//说明订单恰好满足，中断循环，将order1添加移除队列
order.addCompleteCount(order.getCount());
order1.addCompleteCount(order1.getCount());
order1.complete();
order.complete();
this.lastComplete.put(order.getTradeCode(), order.getPrice());
} else {
//说明订单未满足，将order1添加移除队列，并继续循环
order1.complete();
order.addCompleteCount(order1.getRemainCount());
}
count = order.getRemainCount();
}
if (!order.isComplete()) {
list.add(order);
}
}
}
public Long getLastPrice(String security) {
return this.lastComplete.get(security);
}
最高对单个标的物单线程，且订单越多，处理速度越慢
T = f(m*n)
就是对市场的变化进行回放，加入我们的策略得出，如果我们参与其中会有怎么样的结果
首先要了解平时我们说的股票当日价格是如何形成的
股票一旦出售后本身是没有价格的，在每个交易日开始前，交易所会进行集中竞价，最后取买卖集合中的笔数最多的价格作为当日的开盘价
紧接着开始连续竞价
连续竞价中，股票价格为股票的成交价，成交价如下定义：
1. 最高买进申报与最低卖出申报相同，则该价格即为成交价格；
2. 买入申报价格高于即时揭示的最低卖出申报价格时，以即时揭示的最低卖出申报价格为成交价
3. 卖出申报价格低于即时揭示的最高买入申报价格时，以即时揭示的最高买入申报价格为成交价
若需要对股市状况进行回测，首先应该保存当日所有的订单情况，然后对价格进行撮合，若撮合成功，则此时可以算出当前价格
平时我们接受的数据成为股市交易的快照
其中记录着一段时间内的成交量，成交均价，成交总价格等的信息