348 lines
9.7 KiB
C++
348 lines
9.7 KiB
C++
#include "qorderprocessor.h"
|
||
#include <QJsonDocument>
|
||
#include <QJsonArray>
|
||
#include <QDebug>
|
||
#include <immintrin.h>
|
||
#include <algorithm>
|
||
#include <QtConcurrent/QtConcurrent>
|
||
|
||
#include "qlogmanager.h"
|
||
#include "qeventbus.h"
|
||
|
||
QOrderProcessor::QOrderProcessor(QObject *parent)
|
||
: QObject(parent)
|
||
{
|
||
int idealThreads = QThread::idealThreadCount();
|
||
//m_threadPool.setMaxThreadCount(qBound(4, idealThreads, 16));
|
||
m_threadPool.setMaxThreadCount(qBound(4, 6, 8));
|
||
}
|
||
|
||
QOrderProcessor::~QOrderProcessor()
|
||
{
|
||
m_threadPool.waitForDone();
|
||
}
|
||
|
||
void QOrderProcessor::setProcessingEnabled(bool enabled)
|
||
{
|
||
QMutexLocker lock(&m_dataMutex);
|
||
m_enabled = enabled;
|
||
}
|
||
|
||
|
||
double QOrderProcessor::sumQuantity(const QVector<OrderBookEntry>& items)const {
|
||
return std::accumulate(items.begin(), items.end(), 0.0,
|
||
[](double sum, const OrderBookEntry& item) {
|
||
return sum + item.volume;
|
||
});
|
||
}
|
||
|
||
/*
|
||
1. 找到列表中的最大值和次大值
|
||
2. 最大值是次大值的指定倍数
|
||
*/
|
||
OrderBookEntry QOrderProcessor::findMaxVolumeItemEx(const QVector<OrderBookEntry>& items, double volumeRatio) const
|
||
{
|
||
if (items.isEmpty())
|
||
return{};
|
||
|
||
// 特殊情况处理：只有一个元素时无法比较倍数
|
||
if (items.size() == 1) {
|
||
return volumeRatio <= 1.0 ? items[0] : OrderBookEntry{};
|
||
}
|
||
|
||
// 初始化最大值和次大值
|
||
const OrderBookEntry* maxItem = &items[0];
|
||
const OrderBookEntry* secondMaxItem = nullptr;
|
||
double secondMaxVolume = -1.0;
|
||
|
||
// 遍历查找最大值和次大值
|
||
for (int i = 1; i < items.size(); ++i) {
|
||
const OrderBookEntry& item = items[i];
|
||
|
||
if (item.volume > maxItem->volume) {
|
||
// 更新次大值为原最大值
|
||
secondMaxItem = maxItem;
|
||
secondMaxVolume = maxItem->volume;
|
||
|
||
// 更新最大值
|
||
maxItem = &item;
|
||
}
|
||
else if (!secondMaxItem || item.volume > secondMaxVolume) {
|
||
// 更新次大值
|
||
secondMaxItem = &item;
|
||
secondMaxVolume = item.volume;
|
||
}
|
||
}
|
||
|
||
// 检查是否满足倍数条件
|
||
constexpr double EPSILON = 1e-9;
|
||
if (secondMaxItem && maxItem->volume + EPSILON >= secondMaxVolume * volumeRatio) {
|
||
return *maxItem;
|
||
}
|
||
|
||
return OrderBookEntry{};
|
||
}
|
||
|
||
QVector<BigOrderInfo> QOrderProcessor::findMaxVolumeItem(const OrderBookData & data) const
|
||
{
|
||
bool findBigOrder = false;
|
||
BigOrderInfo bigOrderInfo;
|
||
QVector<BigOrderInfo> bigOrderInfoList;
|
||
float volume = m_replyCodeQuantity[data.code];
|
||
const OrderBookEntry* maxItem;
|
||
QVector<OrderBookEntry> items = data.asks;
|
||
for (int i = 0; i < items.size(); i++) {
|
||
|
||
// 不处理刚打开程序时，推送过来的摆盘数据
|
||
if (data.askTime == NULL)
|
||
continue;
|
||
|
||
// 同一个价格挡位的订单中股票数量大于，阈值才有可能是大单
|
||
if (volume < items[i].volume) {
|
||
for (int j = 0; j< items[i].details.size(); j++) // 超过list的最大数量，就不会返回数据了
|
||
{
|
||
try {
|
||
if (volume < items[i].details[j].volume)
|
||
{
|
||
findBigOrder = true;
|
||
|
||
bigOrderInfo.nBigOrderType = 0;
|
||
bigOrderInfo.isBigOrder = findBigOrder;
|
||
bigOrderInfo.code = data.code;
|
||
bigOrderInfo.name = data.name;
|
||
bigOrderInfo.orderId = items[i].details[j].orderId;
|
||
bigOrderInfo.price = items[i].price;
|
||
bigOrderInfo.volume = items[i].details[j].volume;
|
||
bigOrderInfo.level = i + 1;
|
||
bigOrderInfo.svrRecvTime = data.askTime;
|
||
|
||
bigOrderInfoList.append(bigOrderInfo);
|
||
}
|
||
}
|
||
catch (const char* msg) {
|
||
qDebug() << "err findMax";
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
items = data.bids;
|
||
for (int i = 0; i < items.size(); i++) {
|
||
|
||
// 不处理刚打开程序时，推送过来的摆盘数据
|
||
if (data.bidTime == NULL)
|
||
continue;
|
||
|
||
// 同一个价格挡位的订单中股票数量大于，阈值才有可能是大单
|
||
if (volume < items[i].volume) {
|
||
for (int j = 0; j< items[i].details.size(); j++)
|
||
{
|
||
try {
|
||
if (volume < items[i].details[j].volume)
|
||
{
|
||
findBigOrder = true;
|
||
bigOrderInfo.nBigOrderType = 1;
|
||
bigOrderInfo.isBigOrder = findBigOrder;
|
||
bigOrderInfo.code = data.code;
|
||
bigOrderInfo.name = data.name;
|
||
bigOrderInfo.orderId = items[i].details[j].orderId;
|
||
bigOrderInfo.price = items[i].price;
|
||
bigOrderInfo.volume = items[i].details[j].volume;
|
||
bigOrderInfo.svrRecvTime = data.bidTime;
|
||
|
||
bigOrderInfoList.append(bigOrderInfo);
|
||
}
|
||
}
|
||
catch (const char* msg) {
|
||
qDebug() << "err findMax";
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
return bigOrderInfoList;
|
||
}
|
||
//
|
||
//// 1.简单粗暴，直接通过数量阈值进行筛选，遍历全部价格档位
|
||
//// 大单检测接口,返回 QVector<BigOrderInfo>, 暂时找到一个就返回
|
||
//QVector<BigOrderInfo> QOrderProcessor::findMaxVolumeItem(const OrderBookData& data) const;
|
||
//{
|
||
// if (items.isEmpty())
|
||
// return{};
|
||
// bool findBigOrder = false;
|
||
// QVector<BigOrderInfo> bigOrderInfoList;
|
||
//
|
||
// float volume = m_replyCodeQuantity[data.code];
|
||
// const OrderBookEntry* maxItem;
|
||
// for (int i = 0; i < items.size(); i++) {
|
||
// // 同一个价格挡位的订单中股票数量大于，阈值才有可能是大单
|
||
// if (volume < items[i].volume) {
|
||
// for (int j = 0; j< items[i].orderCount; j++)
|
||
// {
|
||
// try {
|
||
// if (items[i].details.size() == 0) continue;
|
||
// if (volume < items[i].details[j].volume)
|
||
// {
|
||
// findBigOrder = true;
|
||
//
|
||
// bigOrderInfo.isBigOrder = findBigOrder;
|
||
// bigOrderInfo.code = data.code;
|
||
// bigOrderInfo.name = data.name;
|
||
// bigOrderInfo.orderId = items[i].details[j].orderId;
|
||
// bigOrderInfo.price = items[i].price;
|
||
// bigOrderInfo.volume = items[i].details[j].volume;
|
||
// bigOrderInfo.svrRecvTime = data.askTime;
|
||
//
|
||
// return bigOrderInfo;
|
||
// }
|
||
// }
|
||
// catch (const char* msg) {
|
||
// qDebug() << "err findMax";
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
|
||
// 大单检测，分为两步：
|
||
// 1、判断股票数量是否达到大单的阈值，未达到时直接返回
|
||
// 2、判断订单详情是否达到大单阈值
|
||
|
||
// 下一步增加摆盘数据统计，大单占全部摆盘数量的比例，计算出来一个置信度
|
||
|
||
// 使用指针遍历避免拷贝
|
||
// 这里是找到当前摆盘数据中，每一档价位数量最大的
|
||
//const OrderBookEntry* maxItem = &items[0];
|
||
//for (int i = 1; i < items.size(); ++i) {
|
||
// if (items[i].volume > maxItem->volume) {
|
||
// maxItem = &items[i];
|
||
// }
|
||
//}
|
||
|
||
// 添加业务规则验证（如果需要）
|
||
// if (!isValidMaxVolumeItem(*maxItem, items))
|
||
// return {};
|
||
|
||
// return bigOrderInfoList;
|
||
//}
|
||
|
||
OrderBookEntry QOrderProcessor::findMinPriceItem(const QVector<OrderBookEntry>& items) const
|
||
{
|
||
if (items.isEmpty()) return{};
|
||
|
||
auto it = std::min_element(items.begin(), items.end(),
|
||
[](const OrderBookEntry& a, const OrderBookEntry& b) {
|
||
return a.price < b.price;
|
||
});
|
||
return it != items.end() ? *it : OrderBookEntry{};
|
||
}
|
||
|
||
// 缓存相关方法 - 手动缓存实现
|
||
bool QOrderProcessor::getCachedResult(const QString& cacheKey, QVector<BigOrderInfo>& result) const
|
||
{
|
||
QMutexLocker lock(&m_cacheMutex);
|
||
if (m_orderCache.contains(cacheKey)) {
|
||
result = m_orderCache.value(cacheKey);
|
||
m_cacheHits++;
|
||
return true;
|
||
}
|
||
m_cacheMisses++;
|
||
return false;
|
||
}
|
||
|
||
void QOrderProcessor::cacheResult(const QString& cacheKey, const QVector<BigOrderInfo>& result) const
|
||
{
|
||
QMutexLocker lock(&m_cacheMutex);
|
||
if (!m_orderCache.contains(cacheKey)) {
|
||
// 如果缓存已满，移除最旧的条目
|
||
if (m_cacheKeys.size() >= m_cacheMaxSize) {
|
||
QString oldestKey = m_cacheKeys.takeFirst();
|
||
m_orderCache.remove(oldestKey);
|
||
}
|
||
|
||
m_orderCache.insert(cacheKey, result);
|
||
m_cacheKeys.append(cacheKey);
|
||
}
|
||
}
|
||
|
||
QVector<BigOrderInfo> QOrderProcessor::findExtremeOrders(const OrderBookData& data) const
|
||
{
|
||
// 生成缓存键
|
||
QString cacheKey = QString("%1_%2_%3").arg(data.code).arg(data.askTime).arg(data.bidTime);
|
||
|
||
// 尝试从缓存获取结果
|
||
QVector<BigOrderInfo> result;
|
||
if (getCachedResult(cacheKey, result)) {
|
||
return result;
|
||
}
|
||
|
||
// 使用现有的算法
|
||
result = findMaxVolumeItem(data);
|
||
|
||
// 缓存结果
|
||
cacheResult(cacheKey, result);
|
||
|
||
return result;
|
||
}
|
||
|
||
/*
|
||
// 设计一个单独的大单检测引擎
|
||
// 包括：历史数据分析、订单分析、成交记录分析
|
||
*/
|
||
void QOrderProcessor::internalProcess(const OrderBookData& orderData)
|
||
{
|
||
if (!m_enabled || orderData.isEmpty()) {
|
||
return;
|
||
}
|
||
|
||
try {
|
||
// 发布处理开始事件
|
||
QEventBus::instance()->publish(EventType::PROCESSING_STARTED,
|
||
QVariant::fromValue(orderData.code),
|
||
"QOrderProcessor");
|
||
|
||
const auto result = findExtremeOrders(orderData);
|
||
|
||
for (int i = 0; i < result.size(); i++)
|
||
{
|
||
if(result.at(i).isBigOrder) {
|
||
// 保持向后兼容，发送原有信号
|
||
emit maxOrderReady(result.at(i));
|
||
|
||
// 发布大单检测事件
|
||
QEventBus::instance()->publish(EventType::BIG_ORDER_DETECTED,
|
||
QVariant::fromValue(result.at(i)),
|
||
"QOrderProcessor");
|
||
}
|
||
}
|
||
|
||
// 发布处理完成事件
|
||
QEventBus::instance()->publish(EventType::PROCESSING_FINISHED,
|
||
QVariant::fromValue(orderData.code),
|
||
"QOrderProcessor");
|
||
}
|
||
catch (const std::exception& e) {
|
||
QString errorMsg = QString::fromUtf8(e.what());
|
||
emit errorOccurred(orderData.code, errorMsg);
|
||
|
||
// 发布错误事件
|
||
QEventBus::instance()->publish(EventType::SYSTEM_ERROR,
|
||
QVariant::fromValue(QString("Order processing error for %1: %2").arg(orderData.code).arg(errorMsg)),
|
||
"QOrderProcessor");
|
||
}
|
||
}
|
||
|
||
void QOrderProcessor::processOrderBook(const Qot_UpdateOrderBook::Response &stRsp)
|
||
{
|
||
QtConcurrent::run(&m_threadPool, [this, stRsp]() {
|
||
try {
|
||
OrderBookData orderBook;
|
||
parser.parse(stRsp.SerializeAsString().c_str(), stRsp.ByteSize(), orderBook);
|
||
|
||
internalProcess(orderBook);
|
||
}
|
||
catch (const std::exception& e) {
|
||
emit errorOccurred("UNKNOWN", QString::fromUtf8(e.what()));
|
||
}
|
||
});
|
||
}
|