副标题：从FIX/FAST协议解析到零拷贝共享内存，源码级剖析行情引擎的全链路性能优化
一、引言：行情数据的"推"与"拉"
在量化交易系统中，行情数据的分发效率直接决定了策略的盈利能力。一个典型的A股Level-2行情，单日产生的tick数据超过500万条，如果处理不当，延迟会迅速累积到不可接受的程度。
两种数据分发模式：
- 快照（Snapshot）：周期性全量推送，简单但带宽浪费
- 增量更新（Incremental Update）：只推送变化，高效但复杂
本文从Qt/C++实战角度，完整剖析一个生产级行情快照与增量更新引擎的架构设计。
二、系统架构：行情引擎的四层模型
┌──────────────────────────────────────────────────┐
│ Layer 4: 行情源适配层 │
│ CTP/飞鼠/掘金/IB API → 统一行情结构体 │
├──────────────────────────────────────────────────┤
│ Layer 3: 快照与增量引擎 │
│ 快照生成 / 增量计算 / 压缩/解压 │
├──────────────────────────────────────────────────┤
│ Layer 2: 数据分发层 │
│ 共享内存 / ZeroMQ / Redis / WebSocket │
├──────────────────────────────────────────────────┤
│ Layer 1: 订阅客户端 │
│ Qt Signal/Slot / 回调 / 事件循环 │
└──────────────────────────────────────────────────┘三、行情数据结构设计
3.1 核心行情结构体
cpp
/**
* 统一行情tick结构体
* 设计要点：内存对齐、POD类型、支持零拷贝序列化
*/
#pragma pack(push, 1) // 1字节对齐，便于网络传输
struct MarketTick
{
// 标识字段
quint64 timestamp; // 纳秒时间戳
char symbol[16]; // 标的代码（固定长度，避免QString开销）
quint32 msgSeqNum; // 消息序号（用于丢包检测）
// 价格字段（使用定点数避免double精度问题）
qint64 lastPrice; // 最新价（×10000，即4位定点）
qint64 openPrice;
qint64 highPrice;
qint64 lowPrice;
qint64 preClose;
// 成交量字段
quint64 volume; // 成交量（手）
quint64 turnover; // 成交额（元，×100）
// 买卖盘（5档）
qint64 bidPrice[5];
quint32 bidVolume[5];
qint64 askPrice[5];
quint32 askVolume[5];
// 状态字段
quint8 tradingPhase; // 交易阶段
quint8 flags; // 标志位（停牌/涨跌停等）
// 计算校验和（用于数据完整性验证）
quint16 checksum() const {
quint16 sum = 0;
const quint16 *p = reinterpret_cast<const quint16*>(this);
for (size_t i = 0; i < sizeof(MarketTick)/2; ++i)
sum += p[i];
return sum;
}
};
#pragma pack(pop)
static_assert(sizeof(MarketTick) == 200, "MarketTick size mismatch!");
// 200字节，刚好适合一个UDP包（通常MTU=1500）3.2 增量更新结构体
cpp
/**
* 增量更新消息
* 只传输变化的字段，极大减少数据量
*/
#pragma pack(push, 1)
struct IncrementalUpdate
{
quint64 timestamp;
char symbol[16];
quint32 msgSeqNum;
quint8 updateMask; // 位掩码：哪些字段有更新
// 可变长度数据区（只有变化的字段才出现）
// 格式：[fieldId(1B)] [value(N bytes)] ...
quint8 data[128]; // 变长数据区
quint8 dataLen; // 实际数据长度
// 字段ID枚举（与updateMask对应）
enum FieldId {
FIELD_LAST_PRICE = 0x01,
FIELD_VOLUME = 0x02,
FIELD_BID_ASK = 0x04, // 买卖盘
FIELD_TURNOVER = 0x08,
// ...
};
/**
* 编码增量更新
* 只编码变化的字段
*/
void encode(const MarketTick &oldTick, const MarketTick &newTick)
{
dataLen = 0;
updateMask = 0;
// 检查最新价是否变化
if (oldTick.lastPrice != newTick.lastPrice) {
updateMask |= FIELD_LAST_PRICE;
data[dataLen++] = FIELD_LAST_PRICE;
qint64 netValue = qToBigEndian(newTick.lastPrice);
memcpy(&data[dataLen], &netValue, 8);
dataLen += 8;
}
// 检查成交量是否变化
if (oldTick.volume != newTick.volume) {
updateMask |= FIELD_VOLUME;
data[dataLen++] = FIELD_VOLUME;
quint64 netVol = qToBigEndian(newTick.volume);
memcpy(&data[dataLen], &netVol, 8);
dataLen += 8;
}
// 检查买卖盘是否变化（批量检查）
bool bidAskChanged = false;
for (int i = 0; i < 5; ++i) {
if (oldTick.bidPrice[i] != newTick.bidPrice[i] ||
oldTick.askPrice[i] != newTick.askPrice[i]) {
bidAskChanged = true;
break;
}
}
if (bidAskChanged) {
updateMask |= FIELD_BID_ASK;
data[dataLen++] = FIELD_BID_ASK;
// 编码全部5档买卖盘
for (int i = 0; i < 5; ++i) {
qint64 netBP = qToBigEndian(newTick.bidPrice[i]);
qint64 netAP = qToBigEndian(newTick.askPrice[i]);
memcpy(&data[dataLen], &netBP, 8); dataLen += 8;
memcpy(&data[dataLen], &netAP, 8); dataLen += 8;
quint32 netBV = qToBigEndian(newTick.bidVolume[i]);
quint32 netAV = qToBigEndian(newTick.askVolume[i]);
memcpy(&data[dataLen], &netBV, 4); dataLen += 4;
memcpy(&data[dataLen], &netAV, 4); dataLen += 4;
}
}
// 写入头部
memcpy(this->data, &dataLen, sizeof(dataLen));
// 实际发送时：sizeof(IncrementalUpdate) - (128 - dataLen)
}
/**
* 解码增量更新并应用到旧tick
*/
void decodeAndApply(MarketTick &tick) const
{
int offset = 0;
while (offset < dataLen) {
quint8 fieldId = data[offset++];
switch (fieldId) {
case FIELD_LAST_PRICE: {
qint64 value;
memcpy(&value, &data[offset], 8);
tick.lastPrice = qFromBigEndian(value);
offset += 8;
break;
}
case FIELD_VOLUME: {
quint64 value;
memcpy(&value, &data[offset], 8);
tick.volume = qFromBigEndian(value);
offset += 8;
break;
}
case FIELD_BID_ASK: {
for (int i = 0; i < 5; ++i) {
qint64 bp, ap;
quint32 bv, av;
memcpy(&bp, &data[offset], 8); offset += 8;
memcpy(&ap, &data[offset], 8); offset += 8;
memcpy(&bv, &data[offset], 4); offset += 4;
memcpy(&av, &data[offset], 4); offset += 4;
tick.bidPrice[i] = qFromBigEndian(bp);
tick.askPrice[i] = qFromBigEndian(ap);
tick.bidVolume[i] = qFromBigEndian(bv);
tick.askVolume[i] = qFromBigEndian(av);
}
break;
}
}
}
}
};
#pragma pack(pop)四、快照引擎实现
4.1 快照生成器
cpp
/**
* 行情快照引擎
* 功能：周期性生成全量快照，供新订阅者快速同步
*/
class MarketSnapshotEngine : public QObject
{
Q_OBJECT
public:
explicit MarketSnapshotEngine(QObject *parent = nullptr)
: QObject(parent), m_snapshotIntervalMs(1000) // 默认1秒1次快照
{
// 高精度定时器（Qt::PreciseTimer）
m_snapshotTimer = new QTimer(this);
m_snapshotTimer->setTimerType(Qt::PreciseTimer);
connect(m_snapshotTimer, &QTimer::timeout,
this, &MarketSnapshotEngine::generateSnapshot);
}
void start() { m_snapshotTimer->start(m_snapshotIntervalMs); }
void stop() { m_snapshotTimer->stop(); }
/**
* 注册行情源
*/
void registerMarketData(const QString &symbol, const MarketTick &tick)
{
QWriteLocker locker(&m_rwLock);
m_latestTicks[symbol] = tick;
}
/**
* 获取最新快照（供新订阅者使用）
*/
QByteArray getSnapshot() const
{
QReadLocker locker(&m_rwLock);
// 序列化所有标的的最新tick
QByteArray snapshot;
QDataStream ds(&snapshot, QIODevice::WriteOnly);
ds.setByteOrder(QDataStream::BigEndian);
ds << (quint32)m_snapshotSeqNum
<< (quint64)QDateTime::currentMSecsSinceEpoch();
for (auto it = m_latestTicks.constBegin();
it != m_latestTicks.constEnd(); ++it) {
ds << it.key();
ds.writeRawData(reinterpret_cast<const char*>(&it.value()),
sizeof(MarketTick));
}
return snapshot;
}
signals:
/**
* 快照生成信号（通过共享内存/网络分发）
*/
void snapshotGenerated(const QByteArray &snapshot);
private slots:
void generateSnapshot()
{
QByteArray snapshot = getSnapshot();
m_snapshotSeqNum++;
// 可选：压缩快照（LZ4比zlib快10倍）
QByteArray compressed = compressLZ4(snapshot);
emit snapshotGenerated(compressed);
}
private:
QByteArray compressLZ4(const QByteArray &data)
{
// 使用LZ4实时压缩（延迟<1ms）
int maxDstSize = LZ4_compressBound(data.size());
QByteArray compressed(maxDstSize, 0);
int compressedSize = LZ4_compress_default(
data.constData(), compressed.data(),
data.size(), maxDstSize);
compressed.resize(compressedSize);
return compressed;
}
QTimer *m_snapshotTimer;
mutable QReadWriteLock m_rwLock;
QMap<QString, MarketTick> m_latestTicks; // symbol → latest tick
quint32 m_snapshotSeqNum = 0;
int m_snapshotIntervalMs;
};4.2 快照压缩优化
cpp
/**
* 差分压缩：只存储与基准快照的差异
* 可将快照大小减少60-80%
*/
class DifferentialSnapshotCompressor : public QObject
{
Q_OBJECT
public:
explicit DifferentialSnapshotCompressor(QObject *parent = nullptr)
: QObject(parent)
{}
/**
* 设置基准快照（reference snapshot）
*/
void setBaseSnapshot(const QByteArray &base) { m_base = base; }
/**
* 压缩当前快照（相对于基准的差分）
*/
QByteArray compressDifferential(const QByteArray ¤t)
{
QByteArray diff;
QDataStream ds(&diff, QIODevice::WriteOnly);
// 使用变长整数编码（Varint）压缩数字
// 价格变化通常很小，varint编码效果显著
const MarketTick *baseTicks = reinterpret_cast<const MarketTick*>(
m_base.constData());
const MarketTick *curTicks = reinterpret_cast<const MarketTick*>(
current.constData());
int count = qMin(m_base.size(), current.size()) / sizeof(MarketTick);
for (int i = 0; i < count; ++i) {
writeVarint(ds, curTicks[i].lastPrice - baseTicks[i].lastPrice);
writeVarint(ds, curTicks[i].volume - baseTicks[i].volume);
// ... 其他字段
}
return diff;
}
private:
void writeVarint(QDataStream &ds, qint64 value)
{
// Varint编码：小数字用1字节，大数字用多字节
quint64 uv = (value < 0) ? (quint64)(-value) * 2 - 1
: (quint64)value * 2;
while (uv > 0x7F) {
ds << quint8((uv & 0x7F) | 0x80);
uv >>= 7;
}
ds << quint8(uv & 0x7F);
}
QByteArray m_base;
};五、增量更新引擎实现
5.1 增量更新分发器
cpp
/**
* 增量更新引擎
* 核心：维护每个订阅者的最后序列号，只推送缺失的更新
*/
class IncrementalUpdateEngine : public QObject
{
Q_OBJECT
public:
explicit IncrementalUpdateEngine(QObject *parent = nullptr)
: QObject(parent), m_ringBufferSize(10000)
{
m_updateRingBuffer.resize(m_ringBufferSize);
m_currentSeqNum = 0;
}
/**
* 发布新的行情更新
*/
void publishUpdate(const QString &symbol, const MarketTick &newTick)
{
QWriteLocker locker(&m_rwLock);
// 1. 计算增量
IncrementalUpdate update;
MarketTick oldTick = m_lastTicks.value(symbol, MarketTick{});
update.encode(oldTick, newTick);
// 2. 写入环形缓冲区
update.msgSeqNum = m_currentSeqNum++;
update.timestamp = QDateTime::currentMSecsSinceEpoch();
strncpy(update.symbol, symbol.toUtf8().constData(), 15);
int ringIdx = update.msgSeqNum % m_ringBufferSize;
m_updateRingBuffer[ringIdx] = update;
// 3. 更新最新tick
m_lastTicks[symbol] = newTick;
// 4. 通知所有订阅者
emit updateAvailable(update);
}
/**
* 订阅者请求缺失的更新（丢包重传）
*/
QVector<IncrementalUpdate> resendUpdates(quint32 fromSeqNum,
int maxCount = 100)
{
QReadLocker locker(&m_rwLock);
QVector<IncrementalUpdate> result;
for (int i = 0; i < maxCount; ++i) {
quint32 seq = fromSeqNum + i;
if (seq >= m_currentSeqNum) break;
int ringIdx = seq % m_ringBufferSize;
if (m_updateRingBuffer[ringIdx].msgSeqNum == seq) {
result << m_updateRingBuffer[ringIdx];
} else {
break; // 序列号不连续，停止
}
}
return result;
}
signals:
/**
* 增量更新可用（通过信号槽/共享内存通知订阅者）
*/
void updateAvailable(const IncrementalUpdate &update);
private:
mutable QReadWriteLock m_rwLock;
QMap<QString, MarketTick> m_lastTicks; // symbol → last tick
QVector<IncrementalUpdate> m_updateRingBuffer; // 环形缓冲区
quint32 m_currentSeqNum;
int m_ringBufferSize;
};5.2 增量更新的Qt信号槽分发
cpp
/**
* 使用Qt信号槽进行高效的增量更新分发
* 优化：使用Qt::QueuedConnection + 自定义事件合并更新
*/
class MarketDataDistributor : public QObject
{
Q_OBJECT
public:
explicit MarketDataDistributor(QObject *parent = nullptr)
: QObject(parent)
{
// 使用自定义事件进行更新合并
m_eventCompressor = new EventCompressor(this);
}
/**
* 订阅行情（返回历史数据 + 增量更新）
*/
void subscribe(const QString &symbol, QObject *receiver,
const char *method)
{
// 1. 立即发送快照
MarketTick snapshot = m_snapshotEngine->getLatestTick(symbol);
QMetaObject::invokeMethod(receiver, method,
Qt::QueuedConnection,
Q_ARG(MarketTick, snapshot));
// 2. 连接增量更新信号
connect(this, SIGNAL(incrementalUpdate(QString,MarketTick)),
receiver, method, Qt::QueuedConnection);
// 3. 记录订阅关系
m_subscribers.insert(symbol, receiver);
}
signals:
/**
* 增量更新信号（带symbol信息）
*/
void incrementalUpdate(const QString &symbol,
const MarketTick &tick);
private slots:
/**
* 合并多个增量更新，减少信号发射次数
*/
void onTickBatchReady(const QVector<MarketTick> &batch)
{
// 对每个symbol，只发送最新的tick
QMap<QString, MarketTick> latestInBatch;
for (const auto &tick : batch) {
QString sym = QString::fromUtf8(tick.symbol, 16).trimmed();
latestInBatch[sym] = tick; // 覆盖为最新
}
// 批量发射信号
for (auto it = latestInBatch.constBegin();
it != latestInBatch.constEnd(); ++it) {
emit incrementalUpdate(it.key(), it.value());
}
}
private:
MarketSnapshotEngine *m_snapshotEngine;
QMultiMap<QString, QObject*> m_subscribers;
EventCompressor *m_eventCompressor;
};
/**
* 事件压缩器：合并短时间内的多个更新事件
*/
class EventCompressor : public QObject
{
Q_OBJECT
public:
explicit EventCompressor(QObject *parent = nullptr)
: QObject(parent), m_batchIntervalMs(5) // 5ms批次窗口
{
m_batchTimer = new QTimer(this);
m_batchTimer->setSingleShot(true);
connect(m_batchTimer, &QTimer::timeout,
this, &EventCompressor::flushBatch);
}
/**
* 添加待处理的更新
*/
void enqueue(const MarketTick &tick)
{
m_pendingBatch << tick;
if (!m_batchTimer->isActive()) {
m_batchTimer->start(m_batchIntervalMs);
}
}
signals:
void batchReady(const QVector<MarketTick> &batch);
private:
void flushBatch()
{
if (!m_pendingBatch.isEmpty()) {
emit batchReady(m_pendingBatch);
m_pendingBatch.clear();
}
}
QVector<MarketTick> m_pendingBatch;
QTimer *m_batchTimer;
int m_batchIntervalMs;
};六、零拷贝共享内存分发
6.1 基于QSharedMemory的高性能分发
cpp
/**
* 共享内存行情分发器
* 实现进程间零拷贝行情分发（延迟<1μs）
*/
class SharedMemoryMarketFeed : public QObject
{
Q_OBJECT
public:
explicit SharedMemoryMarketFeed(const QString &segmentName,
QObject *parent = nullptr)
: QObject(parent), m_segmentName(segmentName)
{
// 创建共享内存段（大小：100万条tick × 200字节 ≈ 200MB）
m_sharedMemory.setKey(segmentName);
if (!m_sharedMemory.create(200 * 1024 * 1024)) {
// 已存在，则attach
if (!m_sharedMemory.attach()) {
qFatal("Failed to create/attach shared memory: %s",
qPrintable(m_sharedMemory.errorString()));
}
}
// 初始化共享内存头部
if (m_sharedMemory.isAttached()) {
void *data = m_sharedMemory.data();
memset(data, 0, m_sharedMemory.size());
}
}
/**
* 发布行情到共享内存
*/
void publish(const QVector<MarketTick> &ticks)
{
m_sharedMemory.lock();
void *base = m_sharedMemory.data();
SharedMemoryHeader *hdr =
reinterpret_cast<SharedMemoryHeader*>(base);
// 写入数据区（紧跟在头部之后）
MarketTick *dataArea =
reinterpret_cast<MarketTick*>(
reinterpret_cast<char*>(base) + sizeof(SharedMemoryHeader));
for (int i = 0; i < ticks.size() && i < hdr->capacity; ++i) {
dataArea[(hdr->writePos + i) % hdr->capacity] = ticks[i];
}
hdr->writePos = (hdr->writePos + ticks.size()) % hdr->capacity;
hdr->count = qMin(hdr->count + ticks.size(), hdr->capacity);
hdr->seqNum++;
m_sharedMemory.unlock();
// 通知所有订阅进程（使用QSystemSemaphore）
m_updateSemaphore.release(ticks.size());
}
/**
* 订阅者读取行情（另一个进程）
*/
QVector<MarketTick> consume()
{
m_sharedMemory.lock();
void *base = m_sharedMemory.data();
SharedMemoryHeader *hdr =
reinterpret_cast<SharedMemoryHeader*>(base);
QVector<MarketTick> result;
if (hdr->readPos != hdr->writePos) {
MarketTick *dataArea =
reinterpret_cast<MarketTick*>(
reinterpret_cast<char*>(base)
+ sizeof(SharedMemoryHeader));
int available = (hdr->writePos - hdr->readPos + hdr->capacity)
% hdr->capacity;
result.reserve(available);
for (int i = 0; i < available; ++i) {
int idx = (hdr->readPos + i) % hdr->capacity;
result << dataArea[idx];
}
hdr->readPos = hdr->writePos; // 消费完毕
}
m_sharedMemory.unlock();
return result;
}
private:
/**
* 共享内存头部结构
*/
struct SharedMemoryHeader {
quint32 magic = 0x4D4B5246; // "MKRF" 魔数
quint32 version = 1;
quint32 capacity = 1000000; // 容量：100万条
quint32 writePos = 0; // 写指针
quint32 readPos = 0; // 读指针
quint32 count = 0; // 当前条目数
quint64 seqNum = 0; // 序列号
qint64 timestamp = 0; // 最后更新时间
};
QSharedMemory m_sharedMemory;
QString m_segmentName;
QSystemSemaphore m_updateSemaphore;
};6.2 共享内存 + 信号量的进程间通知
cpp
/**
* 使用QSystemSemaphore进行进程间通知
* 比QSharedMemory::lock/unlock更高效
*/
class InterProcessNotifier : public QObject
{
Q_OBJECT
public:
// 发布者
explicit InterProcessNotifier(const QString &name,
QObject *parent = nullptr)
: QObject(parent)
, m_semaphore(name + "_sem", 0) // 初始值0
, m_isProducer(true)
{}
// 订阅者
explicit InterProcessNotifier(const QString &name,
bool isProducer,
QObject *parent = nullptr)
: QObject(parent)
, m_semaphore(name + "_sem", 0)
, m_isProducer(isProducer)
{
if (!m_isProducer) {
// 订阅者：启动监听线程
QtConcurrent::run([this]() { listen(); });
}
}
void notify(int count = 1)
{
if (m_isProducer) {
m_semaphore.release(count); // 发布信号
}
}
signals:
void dataAvailable();
private:
void listen()
{
forever {
m_semaphore.acquire(); // 阻塞等待
emit dataAvailable();
}
}
QSystemSemaphore m_semaphore;
bool m_isProducer;
};七、性能优化：全链路延迟分析
7.1 延迟测量工具
cpp
/**
* 纳秒级延迟测量工具
*/
class LatencyProfiler : public QObject
{
Q_OBJECT
public:
explicit LatencyProfiler(QObject *parent = nullptr) : QObject(parent) {}
void recordTimestamp(const QString &tag)
{
quint64 now = QDateTime::currentMSecsSinceEpoch() * 1000000ULL
+ getHighResNanos(); // 需平台相关实现
m_timestamps[tag] = now;
}
void calculateLatency(const QString &startTag, const QString &endTag)
{
quint64 start = m_timestamps.value(startTag, 0);
quint64 end = m_timestamps.value(endTag, 0);
if (start > 0 && end > 0) {
quint64 latencyNs = end - start;
m_latencyHistogram[latencyNs / 1000]++; // 按μs分桶
}
}
void printStats()
{
quint64 total = 0;
for (auto it = m_latencyHistogram.constBegin();
it != m_latencyHistogram.constEnd(); ++it) {
total += it.value();
}
// 计算P50/P95/P99
quint64 cumulative = 0;
quint64 p50 = 0, p95 = 0, p99 = 0;
for (auto it = m_latencyHistogram.constBegin();
it != m_latencyHistogram.constEnd(); ++it) {
cumulative += it.value();
double pct = (double)cumulative / total * 100.0;
if (p50 == 0 && pct >= 50.0) p50 = it.key();
if (p95 == 0 && pct >= 95.0) p95 = it.key();
if (p99 == 0 && pct >= 99.0) p99 = it.key();
}
qDebug() << "延迟统计 (μs):";
qDebug() << " P50:" << p50;
qDebug() << " P95:" << p95;
qDebug() << " P99:" << p99;
}
private:
QMap<QString, quint64> m_timestamps;
QMap<quint64, quint64> m_latencyHistogram; // μs → count
};7.2 性能优化清单
| 优化项 | 效果 | 实现方式 |
|---|---|---|
| 零拷贝共享内存 | 延迟从100μs降至<1μs | QSharedMemory + 自定义序列化 |
| 事件合并（5ms窗口） | 信号发射减少90% | EventCompressor类 |
| LZ4压缩 | 带宽减少70%，延迟增加<1ms | LZ4_compress_fast |
| 差分编码 | 快照大小减少80% | 只存储与基准的差异 |
| Varint编码 | 小数字1字节 | 自定义writeVarint |
| 环形缓冲区 | 避免内存分配 | QVector + 取模运算 |
| 读写锁 | 读并发性能提升 | QReadWriteLock |
| Qt::DirectConnection | 信号槽延迟减少 | 同线程使用DirectConnection |
八、完整实战：行情引擎Demo
cpp
#include <QApplication>
#include <QMainWindow>
#include <QWidget>
#include <QVBoxLayout>
#include <QHBoxLayout>
#include <QTableWidget>
#include <QLabel>
#include <QPushButton>
#include <QTimer>
#include <QDateTime>
#include <QRandomGenerator>
#include <QMap>
// ============ 简化版行情结构体 ============
struct SimpleTick {
QString symbol;
double lastPrice;
double volume;
double bid[5];
double ask[5];
qint64 timestamp;
};
// ============ 行情引擎 ============
class MarketDataEngine : public QObject
{
Q_OBJECT
public:
explicit MarketDataEngine(QObject *parent = nullptr)
: QObject(parent)
{
// 模拟行情推送（100ms一个tick）
auto *timer = new QTimer(this);
connect(timer, &QTimer::timeout, this, [this]() {
simulateMarketData();
});
timer->start(100);
}
signals:
void tickArrived(const SimpleTick &tick);
private:
void simulateMarketData()
{
QString symbols[] = {"600519.SH", "000001.SZ", "600036.SH"};
for (const QString &sym : symbols) {
SimpleTick tick;
tick.symbol = sym;
tick.timestamp = QDateTime::currentMSecsSinceEpoch();
// 模拟价格变动
double &price = m_lastPrices[sym];
if (price == 0) price = 100.0;
double delta = (QRandomGenerator::global()->bounded(200) - 100)
/ 100.0;
price += delta;
tick.lastPrice = price;
tick.volume += QRandomGenerator::global()->bounded(1000);
// 模拟买卖盘
for (int i = 0; i < 5; ++i) {
tick.bid[i] = price - 0.01 * (i + 1);
tick.ask[i] = price + 0.01 * (i + 1);
}
emit tickArrived(tick);
}
}
QMap<QString, double> m_lastPrices;
};
// ============ 行情显示窗口 ============
class MarketDataWidget : public QWidget
{
Q_OBJECT
public:
explicit MarketDataWidget(QWidget *parent = nullptr)
: QWidget(parent)
{
setupUI();
m_engine = new MarketDataEngine(this);
connect(m_engine, &MarketDataEngine::tickArrived,
this, &MarketDataWidget::onTickArrived,
Qt::QueuedConnection);
}
private:
void setupUI()
{
auto *mainLayout = new QVBoxLayout(this);
// 标题
auto *title = new QLabel("📊 实时行情快照与增量更新");
title->setStyleSheet("font-size: 16px; font-weight: bold; "
"color: #00ff88; padding: 8px;");
mainLayout->addWidget(title);
// 行情表格
m_table = new QTableWidget(0, 8, this);
m_table->setHorizontalHeaderLabels(
{"标的", "最新价", "涨跌", "成交量", "买一", "卖一",
"更新时间", "延迟(μs)"});
m_table->horizontalHeader()->setStretchLastSection(true);
m_table->setAlternatingRowColors(true);
mainLayout->addWidget(m_table);
// 统计信息
m_statsLabel = new QLabel("总更新次数: 0 | "
"平均延迟: -- μs | "
"丢包数: 0");
m_statsLabel->setStyleSheet("color: #aaa; font-size: 11px;");
mainLayout->addWidget(m_statsLabel);
setStyleSheet(
"QWidget { background-color: #1a1a2e; color: #e0e0e0; }"
"QTableWidget { gridline-color: #333; }"
"QHeaderView::section { background-color: #16213e; "
"color: #4488ff; padding: 4px; }");
}
private slots:
void onTickArrived(const SimpleTick &tick)
{
m_updateCount++;
// 查找或创建行
int row = -1;
for (int i = 0; i < m_table->rowCount(); ++i) {
if (m_table->item(i, 0)->text() == tick.symbol) {
row = i;
break;
}
}
if (row == -1) {
row = m_table->rowCount();
m_table->insertRow(row);
for (int c = 0; c < 8; ++c) {
m_table->setItem(row, c, new QTableWidgetItem);
}
}
// 更新数据
m_table->item(row, 0)->setText(tick.symbol);
m_table->item(row, 1)->setText(
QString::number(tick.lastPrice, 'f', 2));
double change = tick.lastPrice - 100.0; // 假设昨收100
auto *changeItem = m_table->item(row, 2);
changeItem->setText(QString("%1%2")
.arg(change >= 0 ? "+" : "")
.arg(change, 0, 'f', 2));
changeItem->setForeground(change >= 0 ? QColor("#00ff88")
: QColor("#ff4444"));
m_table->item(row, 3)->setText(
QString::number(tick.volume, 'f', 0));
m_table->item(row, 4)->setText(
QString::number(tick.bid[0], 'f', 2));
m_table->item(row, 5)->setText(
QString::number(tick.ask[0], 'f', 2));
m_table->item(row, 6)->setText(
QDateTime::fromMSecsSinceEpoch(tick.timestamp)
.toString("hh:mm:ss.zzz"));
// 计算延迟
qint64 now = QDateTime::currentMSecsSinceEpoch();
qint64 latency = (now * 1000) - (tick.timestamp * 1000);
m_table->item(row, 7)->setText(QString::number(latency));
// 更新统计
if (m_updateCount % 10 == 0) {
m_totalLatency += latency;
m_avgLatency = m_totalLatency / (m_updateCount / 10);
m_statsLabel->setText(
QString("总更新次数: %1 | 平均延迟: %2 μs | 丢包数: %3")
.arg(m_updateCount)
.arg(m_avgLatency)
.arg(m_dropCount));
}
}
private:
QTableWidget *m_table;
QLabel *m_statsLabel;
MarketDataEngine *m_engine;
qint64 m_updateCount = 0;
qint64 m_totalLatency = 0;
qint64 m_avgLatency = 0;
qint64 m_dropCount = 0;
};
// ============ 主窗口 ============
class MainWindow : public QMainWindow
{
Q_OBJECT
public:
explicit MainWindow(QWidget *parent = nullptr) : QMainWindow(parent)
{
setCentralWidget(new MarketDataWidget(this));
setWindowTitle("Qt行情快照与增量更新引擎实战");
resize(1000, 600);
}
};
int main(int argc, char *argv[])
{
QApplication app(argc, argv);
QApplication::setFont(QFont("Microsoft YaHei", 9));
MainWindow w;
w.show();
return app.exec();
}
#include "main.moc"九、总结与最佳实践
行情引擎设计核心要点：
- 快照 + 增量更新 是标准组合：快照用于初始化，增量用于实时更新
- 零拷贝共享内存 是进程间行情分发的最佳选择
- 事件合并 能大幅减少信号槽开销
- 环形缓冲区 避免内存分配，适合高频写入
- 差分编码 + LZ4压缩 在带宽和延迟间取得平衡
延迟优化层级：
应用层：事件合并、信号槽优化 → 延迟减少50-80%
传输层：零拷贝共享内存、LZ4压缩 → 延迟减少90%
系统层：CPU亲和性、内存大页 → 延迟减少20-30%
网络层：kernel bypass、RDMA → 延迟减少95%（机构级）《注：若有发现问题欢迎大家提出来纠正》
以上仅为技术分享参考，不构成投资建议