hikyuu 2.1.3__cp310-none-win_amd64.whl → 2.1.5__cp310-none-win_amd64.whl

hikyuu/gui/data/UsePytdxImportToH5Thread.py

@@ -84,14 +84,8 @@ class UsePytdxImportToH5Thread(QThread):
     def init_task(self):
         config = self.config
         dest_dir = config['hdf5']['dir']
-        sqlite_file_name = dest_dir + "/stock.db"
 
         self.tasks = []
-        if self.config.getboolean('weight', 'enable', fallback=False):
-            self.tasks.append(
-                ImportWeightToSqliteTask(self.log_queue, self.queue,
-                                         self.config, dest_dir))
-
         if self.config.getboolean('finance', 'enable', fallback=True):
             self.tasks.append(
                 ImportHistoryFinanceTask(self.log_queue, self.queue, self.config, dest_dir))
@@ -112,6 +106,8 @@ class UsePytdxImportToH5Thread(QThread):
             task_count += market_count
         if self.config.getboolean('ktype', 'time', fallback=False):
             task_count += market_count
+        if self.config.getboolean('weight', 'enable', fallback=False):
+            task_count += (market_count*2)
 
         self.logger.info('搜索通达信服务器')
         self.send_message(['INFO', '搜索通达信服务器'])
@@ -210,6 +206,19 @@ class UsePytdxImportToH5Thread(QThread):
                         start_date.month * 1000000 + start_date.day * 10000))
                 cur_host += 1
 
+        if self.config.getboolean('weight', 'enable', fallback=False):
+            for market in g_market_list:
+                self.tasks.append(
+                    ImportWeightToSqliteTask(self.log_queue, self.queue,
+                                             self.config, dest_dir, market, 'weight', use_hosts[cur_host][0],
+                                             use_hosts[cur_host][1]))
+                cur_host += 1
+                self.tasks.append(
+                    ImportWeightToSqliteTask(self.log_queue, self.queue,
+                                             self.config, dest_dir, market, 'finance', use_hosts[cur_host][0],
+                                             use_hosts[cur_host][1]))
+                cur_host += 1
+
     def run(self):
         try:
             self.init_task()
@@ -298,6 +307,8 @@ class UsePytdxImportToH5Thread(QThread):
                         self.send_message([taskname, ktype])
                     elif taskname == 'IMPORT_ZH_BOND10':
                         self.send_message([taskname, ktype])
+                    elif taskname == 'IMPORT_WEIGHT':
+                        pass
                     else:
                         self.send_message([taskname, 'FINISHED'])
                     continue

hikyuu/gui/data/UseTdxImportToH5Thread.py

@@ -30,7 +30,10 @@ from hikyuu.gui.data.ImportTdxToH5Task import ImportTdxToH5Task
 from hikyuu.gui.data.ImportWeightToSqliteTask import ImportWeightToSqliteTask
 from hikyuu.gui.data.ImportHistoryFinanceTask import ImportHistoryFinanceTask
 
+from pytdx.hq import TdxHq_API
+from hikyuu.data.common import g_market_list
 from hikyuu.data.common_sqlite3 import create_database
+from hikyuu.data.common_pytdx import search_best_tdx
 from hikyuu.data.tdx_to_h5 import tdx_import_stock_name_from_file
 from hikyuu.util import *
 
@@ -57,18 +60,39 @@ class UseTdxImportToH5Thread(QThread):
             self.quotations.append('stock')
         if self.config['quotation']['fund']:
             self.quotations.append('fund')
-        #if self.config['quotation']['future']:
+        # if self.config['quotation']['future']:
         #    self.quotations.append('future')
 
-        #通达信盘后没有债券数据。另外，如果用Pytdx下载债券数据，
-        #每个债券本身的数据很少但债券种类太多占用空间和时间太多，用途较少不再考虑导入
-        #if self.config['quotation']['bond']:
+        # 通达信盘后没有债券数据。另外，如果用Pytdx下载债券数据，
+        # 每个债券本身的数据很少但债券种类太多占用空间和时间太多，用途较少不再考虑导入
+        # if self.config['quotation']['bond']:
         #    self.quotations.append('bond')
 
+        hosts = search_best_tdx()
+        api = TdxHq_API()
+        hku_check(api.connect(hosts[0][2], hosts[0][3]), "failed connect pytdx {}:{}!", hosts[0][2], hosts[0][3])
+
         self.queue = Queue()
         self.tasks = []
+
+        cur_host = 0
         if self.config.getboolean('weight', 'enable', fallback=False):
-            self.tasks.append(ImportWeightToSqliteTask(self.log_queue, self.queue, self.config, dest_dir))
+            for market in g_market_list:
+                self.tasks.append(
+                    ImportWeightToSqliteTask(self.log_queue, self.queue,
+                                             self.config, dest_dir, market, 'weight', hosts[cur_host][2],
+                                             hosts[cur_host][3]))
+                cur_host += 1
+                if cur_host >= len(hosts):
+                    cur_host = 0
+                self.tasks.append(
+                    ImportWeightToSqliteTask(self.log_queue, self.queue,
+                                             self.config, dest_dir, market, 'finance', hosts[cur_host][2],
+                                             hosts[cur_host][3]))
+                cur_host += 1
+                if cur_host >= len(hosts):
+                    cur_host = 0
+
         if self.config.getboolean('finance', 'enable', fallback=True):
             self.tasks.append(ImportHistoryFinanceTask(self.log_queue, self.queue, self.config, dest_dir))
         if self.config.getboolean('ktype', 'day', fallback=False):
@@ -115,7 +139,7 @@ class UseTdxImportToH5Thread(QThread):
         dest_dir = self.config['hdf5']['dir']
         hdf5_import_progress = {'SH': {'DAY': 0, '1MIN': 0, '5MIN': 0}, 'SZ': {'DAY': 0, '1MIN': 0, '5MIN': 0}}
 
-        #正在导入代码表
+        # 正在导入代码表
         self.send_message(['START_IMPORT_CODE'])
 
         connect = sqlite3.connect(dest_dir + "/stock.db")

hikyuu/gui/spot_server.py

@@ -271,7 +271,9 @@ def collect(server, use_proxy, source, seconds, phase1, phase2, ignore_weekend):
 
     sm = StockManager.instance()
     if source == 'qmt':
-        stk_list = [s for s in sm if s.valid]
+        stk_list = [s for s in sm if s.valid and s.type in (
+            constant.STOCKTYPE_A, constant.STOCKTYPE_INDEX, constant.STOCKTYPE_ETF,
+            constant.STOCKTYPE_GEM, constant.STOCKTYPE_START, constant.STOCKTYPE_A_BJ)]
     else:
         stk_list = [
             stk.market_code.lower() for stk in sm if stk.valid and stk.type in

hikyuu/gui/start_qmt.py

@@ -2,15 +2,15 @@
 # -*- coding: utf-8 -*-
 
 
-from hikyuu.fetcher.stock.zh_stock_a_qmt import parse_one_result_qmt
+from hikyuu.fetcher.stock.zh_stock_a_qmt import parse_one_result_qmt, get_spot
 from hikyuu.gui.spot_server import release_nng_senders, start_send_spot, end_send_spot, send_spot
 
 
 def callback(datas):
     records = []
     for stock_code, data in datas.items():
-        # print(stock_code, data)
         records.append(parse_one_result_qmt(stock_code, data))
+    # print(len(records))
 
     if records:
         start_send_spot()
@@ -19,18 +19,104 @@ def callback(datas):
 
 
 if __name__ == "__main__":
-    from hikyuu.interactive import *
-    from xtquant import xtdata
+    import os
+    import configparser
+
+    from hikyuu.data.hku_config_template import generate_default_config
+    from hikyuu import *
+
+    config_file = os.path.expanduser('~') + "/.hikyuu/hikyuu.ini"
+    if not os.path.exists(config_file):
+        # 创建默认配置
+        hku_info("创建默认配置文件")
+        generate_default_config()
+
+    ini = configparser.ConfigParser()
+    ini.read(config_file, encoding='utf-8')
+    hku_param = Parameter()
+    hku_param["tmpdir"] = ini.get('hikyuu', 'tmpdir')
+    hku_param["datadir"] = ini.get('hikyuu', 'datadir')
+    if ini.has_option('hikyuu', 'quotation_server'):
+        hku_param["quotation_server"] = ini['hikyuu']['quotation_server']
+
+    # 不加载历史财务信息及权息数据
+    hku_param["load_history_finance"] = False
+    hku_param["load_stock_weight"] = False
+
+    base_param = Parameter()
+    base_info_config = ini.options('baseinfo')
+    for p in base_info_config:
+        base_param[p] = ini.get('baseinfo', p)
+
+    block_param = Parameter()
+    block_config = ini.options('block')
+    for p in block_config:
+        block_param[p] = ini.get('block', p)
+
+    # 不使用配置文件中的预加载参数
+    preload_param = Parameter()
+    if p in Query.get_all_ktype():
+        preload_param[p] = False
 
-    code_list = [f'{s.code}.{s.market}' for s in sm if s.valid]
-    # code_list = ['000001.SZ']
+    kdata_param = Parameter()
+    kdata_config = ini.options('kdata')
+    for p in kdata_config:
+        if p == "convert":
+            kdata_param[p] = ini.getboolean('kdata', p)
+            continue
+        kdata_param[p] = ini.get('kdata', p)
 
+    context = StrategyContext(["all"])
+    context.ktype_list = ["day"]
+
+    sm.init(base_param, block_param, kdata_param, preload_param, hku_param, context)
+
+    # 后续希望每次先主动获取一次全部的tick, 这里需要等待所有数据加载完毕，以便保证全部证券收到第一次tick通知
+    hku_info("waiting all data loaded ...")
+    while not sm.data_ready:
+        import time
+        time.sleep(100)
+
+    stk_list = [s for s in sm if s.valid and s.type in (
+        constant.STOCKTYPE_A, constant.STOCKTYPE_INDEX, constant.STOCKTYPE_ETF,
+        constant.STOCKTYPE_GEM, constant.STOCKTYPE_START, constant.STOCKTYPE_A_BJ)]
+
+    hku_info("start xtquant")
+    code_list = [f'{s.code}.{s.market}' for s in stk_list]
+    from xtquant import xtdata
     xtdata.subscribe_whole_quote(code_list, callback)
 
-    try:
-        xtdata.run()
-    except Exception as e:
-        hku_error(e)
-    finally:
-        # 退出释放资源
-        release_nng_senders()
+    # 每日 9:30 时，主动读取行情一次，以便 hikyuu 生成当日首个分钟线
+    while True:
+        try:
+            today = Datetime.today()
+            if today.day_of_week() not in (0, 6) and not sm.is_holiday(today):
+                hku_info("get full tick ...")
+                start_send_spot()
+                records = get_spot(stk_list, None, None, send_spot)
+                end_send_spot()
+            now = Datetime.now()
+            today_open = today + TimeDelta(0, 9, 30)
+            if now < today_open:
+                delta = today_open - Datetime.now()
+            else:
+                delta = today_open + Days(1) - Datetime.now()
+            hku_info(f"start timer: {delta}s")
+            time.sleep(delta.total_seconds())
+        except KeyboardInterrupt:
+            print("Ctrl-C 终止")
+            break
+        except Exception as e:
+            hku_error(e)
+            time.sleep(10)
+
+    release_nng_senders()
+
+    # try:
+    #     xtdata.run()
+    # except Exception as e:
+    #     hku_error(e)
+    # finally:
+    #     # 退出释放资源
+    #     release_nng_senders()
+    #     exit(0)

hikyuu/include/hikyuu/KQuery.h

@@ -70,10 +70,13 @@ public:
     // static const string INVALID_KTYPE;
 
     /** 获取所有的 KType */
-    static vector<string>& getAllKType();
+    static const vector<KType>& getAllKType();
 
     static int32_t getKTypeInMin(KType);
 
+    /** 判断是否为有效 ktype */
+    static bool isKType(const string& ktype);
+
     /**
      * 复权类型
      * @note 日线以上，如周线/月线不支持复权
@@ -93,7 +96,7 @@ public:
       m_end(Null<int64_t>()),
       m_queryType(INDEX),
       m_dataType(DAY),
-      m_recoverType(NO_RECOVER){};
+      m_recoverType(NO_RECOVER) {};
 
     /**
      * K线查询，范围[start, end)

hikyuu/include/hikyuu/KRecord.h

@@ -24,7 +24,7 @@ public:
     price_t highPrice;    ///< 最高价
     price_t lowPrice;     ///< 最低价
     price_t closePrice;   ///< 收盘价
-    price_t transAmount;  ///< 成交金额（千元）
+    price_t transAmount;  ///< 成交金额（万元）
     price_t transCount;   ///< 成交量（手），日线以下为股数
 
     KRecord()

hikyuu/include/hikyuu/Stock.h

@@ -162,7 +162,7 @@ public:
      */
     bool getIndexRange(const KQuery& query, size_t& out_start, size_t& out_end) const;
 
-    /** 获取指定索引的K线数据记录，未作越界检查 */
+    /** 获取指定索引的K线数据记录，pos 无效时返回 Null<KRecord> */
     KRecord getKRecord(size_t pos, const KQuery::KType& dataType = KQuery::DAY) const;
 
     /** 根据数据类型（日线/周线等），获取指定日期的KRecord */

hikyuu/include/hikyuu/StockManager.h

@@ -10,8 +10,9 @@
 
 #include <mutex>
 #include <thread>
-#include "utilities/Parameter.h"
-#include "data_driver/DataDriverFactory.h"
+#include "hikyuu/utilities/Parameter.h"
+#include "hikyuu/utilities/thread/thread.h"
+#include "hikyuu/data_driver/DataDriverFactory.h"
 #include "Block.h"
 #include "MarketInfo.h"
 #include "StockTypeInfo.h"
@@ -21,9 +22,6 @@ namespace hku {
 
 typedef vector<string> MarketList;
 
-Parameter default_preload_param();
-Parameter default_other_param();
-
 /**
  * 证券信息统一管理类
  * @ingroup StockManage
@@ -47,8 +45,8 @@ public:
      * @param context 策略上下文
      */
     void init(const Parameter& baseInfoParam, const Parameter& blockParam,
-              const Parameter& kdataParam, const Parameter& preloadParam = default_preload_param(),
-              const Parameter& hikyuuParam = default_other_param(),
+              const Parameter& kdataParam, const Parameter& preloadParam,
+              const Parameter& hikyuuParam,
               const StrategyContext& context = StrategyContext({"all"}));
 
     /** 重新加载 */
@@ -90,6 +88,9 @@ public:
     /** 获取证券数量 */
     size_t size() const;
 
+    /** 是否所有数据准备完毕 */
+    bool dataReady() const;
+
     /**
      * 根据"市场简称证券代码"获取对应的证券实例
      * @param querystr 格式：“市场简称证券代码”，如"sh000001"
@@ -218,6 +219,11 @@ public:
         return m_thread_id;
     }
 
+    /** 仅由程序退出使使用！！！ */
+    ThreadPool* getLoadTaskGroup() {
+        return m_load_tg.get();
+    }
+
 public:
     typedef StockMapIterator const_iterator;
     const_iterator begin() const {
@@ -228,8 +234,8 @@ public:
     }
 
 private:
-    /* 设置K线驱动 */
-    void setKDataDriver(const KDataDriverConnectPoolPtr&);
+    /* 加载全部数据 */
+    void loadData();
 
     /* 加载 K线数据至缓存 */
     void loadAllKData();
@@ -255,15 +261,13 @@ private:
     /** 加载历史财经字段索引 */
     void loadHistoryFinanceField();
 
-    /** 加载历史财务数据 */
-    void loadHistoryFinance();
-
 private:
     StockManager();
 
 private:
     static StockManager* m_sm;
     std::atomic_bool m_initializing;
+    std::atomic_bool m_data_ready;  // 用于指示是否所有数据准备完毕
     std::thread::id m_thread_id;  // 记录线程id，用于判断Stratege是以独立进程方式还是线程方式运行
     string m_tmpdir;
     string m_datadir;
@@ -271,18 +275,18 @@ private:
     BlockInfoDriverPtr m_blockDriver;
 
     StockMapIterator::stock_map_t m_stockDict;  // SH000001 -> stock
-    std::mutex* m_stockDict_mutex;
+    std::shared_mutex* m_stockDict_mutex;
 
     typedef unordered_map<string, MarketInfo> MarketInfoMap;
     mutable MarketInfoMap m_marketInfoDict;
-    std::mutex* m_marketInfoDict_mutex;
+    std::shared_mutex* m_marketInfoDict_mutex;
 
     typedef unordered_map<uint32_t, StockTypeInfo> StockTypeInfoMap;
     mutable StockTypeInfoMap m_stockTypeInfo;
-    std::mutex* m_stockTypeInfo_mutex;
+    std::shared_mutex* m_stockTypeInfo_mutex;
 
     std::unordered_set<Datetime> m_holidays;  // 节假日
-    std::mutex* m_holidays_mutex;
+    std::shared_mutex* m_holidays_mutex;
 
     ZhBond10List m_zh_bond10;  // 10年期中国国债收益率数据
 
@@ -295,18 +299,20 @@ private:
     Parameter m_preloadParam;
     Parameter m_hikyuuParam;
     StrategyContext m_context;
+
+    std::unique_ptr<ThreadPool> m_load_tg;  // 异步数据加载辅助线程组
 };
 
 inline size_t StockManager::size() const {
     return m_stockDict.size();
 }
 
-inline Stock StockManager::operator[](const string& query) const {
-    return getStock(query);
+inline bool StockManager::dataReady() const {
+    return m_data_ready;
 }
 
-inline bool StockManager::isHoliday(const Datetime& d) const {
-    return m_holidays.count(d);
+inline Stock StockManager::operator[](const string& query) const {
+    return getStock(query);
 }
 
 inline const Parameter& StockManager::getBaseInfoDriverParameter() const {

hikyuu/include/hikyuu/StrategyContext.h

@@ -12,55 +12,96 @@
 
 namespace hku {
 
+/**
+ * 策略上下文，定义策略执行时包含的证券/K线级别信息
+ * @ingroup Strategy
+ *
+ */
 class HKU_API StrategyContext {
 public:
-    StrategyContext() {}
-    StrategyContext(const StrategyContext&) = default;
-
-    explicit StrategyContext(const vector<string>& stockCodeList)
-    : m_stockCodeList(stockCodeList) {}
-    explicit StrategyContext(vector<string>&& stockCodeList)
-    : m_stockCodeList(std::move(stockCodeList)) {}
-
-    StrategyContext(const vector<string>& stockCodeList, const vector<KQuery::KType>& ktypeList)
-    : m_stockCodeList(stockCodeList), m_ktypeList(ktypeList) {}
-
+    StrategyContext() = default;
     virtual ~StrategyContext() = default;
 
+    /**
+     * 构造函数
+     * @note 未指定 ktypelist 时，默认按预加载参数加载全部
+     * @param stockCodeList 指定的证券代码列表，如：如：{"sz000001", "sz000002"}
+     */
+    explicit StrategyContext(const vector<string>& stockCodeList);
+
+    /**
+     * 构造函数
+     * @note 证券列表中如果包含 ("ALL") 则表示全部证券;
+     * 指定K线类型列表同时影响着K线数据的优先加载顺序，靠前的将优先加载。同时受系统配置中预加载参数影响！
+     * @param stockCodeList 指定的证券代码列表，如：{"sh000001", "sz000001"}
+     * @param ktypeList 指定的 K线数据列表，如：{"day", "min"}
+     */
+    StrategyContext(const vector<string>& stockCodeList, const vector<KQuery::KType>& ktypeList);
+
+    // 自定义移动构造与赋值会引起 python 中无法正常退出
+    // StrategyContext(const StrategyContext&) = default;
+    // StrategyContext(StrategyContext&& rv) = delete;
+    // StrategyContext& operator=(const StrategyContext&) = default;
+    // StrategyContext& operator=(StrategyContext&&) = delete;
+
+    /**
+     * 是否为加载全部证券，只要 stockCodeList 包含 "ALL"(不区分大小写) ，即认为加载全部
+     * @return true
+     * @return false
+     */
     bool isAll() const noexcept;
 
-    bool isValid() const noexcept;
+    bool empty() const noexcept {
+        return m_stockCodeList.empty();
+    }
 
     Datetime startDatetime() const noexcept {
         return m_startDatetime;
     }
 
-    void startDatetime(const Datetime& d) {
-        HKU_CHECK(!d.isNull(), "Don't use null datetime!");
-        m_startDatetime = d;
-    }
-
-    void setStockCodeList(vector<string>&& stockList) {
-        m_stockCodeList = std::move(stockList);
+    void setStockCodeList(const vector<string>& stockList) {
+        _removeDuplicateCode(stockList);
     }
 
-    void setStockCodeList(const vector<string>& stockList);
-
-    const vector<string>& getStockCodeList() const {
+    const vector<string>& getStockCodeList() const noexcept {
         return m_stockCodeList;
     }
 
-    void setKTypeList(const vector<KQuery::KType>& ktypeList);
+    void setKTypeList(const vector<KQuery::KType>& ktypeList) {
+        _checkAndRemoveDuplicateKType(ktypeList);
+    }
 
-    /** 该返回的 ktype 列表，已经按从小到大进行排序 */
-    const vector<KQuery::KType>& getKTypeList() const {
+    const vector<KQuery::KType>& getKTypeList() const noexcept {
         return m_ktypeList;
     }
 
+    /**
+     * 隐含的默认必须被加载的证券列表
+     * @note 影响交易日历判断、和某些常被作为默认比较基准的证券，通常被作为某些函数的默认值
+     */
+    const vector<string>& getMustLoadStockCodeList() const noexcept {
+        return m_mustLoad;
+    }
+
+    /**
+     * 返回所有需要加载的证券列表（含指定的证券列表和默认包含必须加载的证券列表）
+     * @return vector<string>
+     */
+    vector<string> getAllNeedLoadStockCodeList() const noexcept;
+
+    string str() const;
+
+private:
+    void _removeDuplicateCode(const vector<string>& stockCodeList);
+    void _checkAndRemoveDuplicateKType(const vector<KQuery::KType>& ktypeList);
+
 private:
     Datetime m_startDatetime{19901219};
+    vector<string> m_mustLoad{"sh000001", "sh000300"};  // 默认必须加载的 stock
     vector<string> m_stockCodeList;
     vector<KQuery::KType> m_ktypeList;
 };
 
+HKU_API std::ostream& operator<<(std::ostream& os, const StrategyContext& context);
+
 }  // namespace hku

hikyuu/include/hikyuu/data_driver/BaseInfoDriver.h

@@ -123,6 +123,7 @@ public:
      * @param market 市场简称
      * @param code 证券代码
      * @param start 财务报告发布起始日期
+     * @param end 查询结束日期
      * @return vector<float> [[财务报告发布日期(ymd), 字段1, 字段2, ...], ...]
      */
     virtual vector<HistoryFinanceInfo> getHistoryFinance(const string& market, const string& code,

hikyuu/include/hikyuu/doc.h

@@ -137,7 +137,7 @@
  * @details 合成多因子
  * @ingroup TradeSystem
  *
- * @defgroup Stratgy Strategy 策略运行时
+ * @defgroup Strategy Strategy 策略运行时
  * @details 策略运行时
  * @ingroup Hikyuu
  *

hikyuu/include/hikyuu/global/GlobalSpotAgent.h

@@ -13,9 +13,12 @@ namespace hku {
 /**
  * 启动 Spot 数据接收代理，如果之前已经处于运行状态，将抛出异常
  * @param print 打印接收数据进展
+ * @param worker_num 接收数据后处理时的工作任务组线程数
+ * @param addr 服务端地址，为空表示使用 hikyuu 配置文件中的行情服务器地址
  * @ingroup Agent
  */
-void HKU_API startSpotAgent(bool print = true);
+void HKU_API startSpotAgent(bool print = true, size_t worker_num = 1,
+                            const string& addr = string());
 
 /**
  * 终止 Spot 数据接收代理
@@ -25,6 +28,6 @@ void HKU_API stopSpotAgent();
 
 SpotAgent* getGlobalSpotAgent();
 
-void releaseGlobalSpotAgent();
+void HKU_API releaseGlobalSpotAgent();
 
 }  // namespace hku

hikyuu/include/hikyuu/global/agent/SpotAgent.h

@@ -43,12 +43,31 @@ public:
         return !m_stop;
     }
 
+    void setWorkerNum(size_t worker_num) {
+        m_work_num = worker_num;
+    }
+
+    size_t getWorkerNum() const {
+        return m_work_num;
+    }
+
     /** 设置是否打印数据接收进展情况，主要用于在交互环境下关闭打印 */
     void setPrintFlag(bool print) {
-        std::lock_guard<std::mutex> lock(m_mutex);
         m_print = print;
     }
 
+    bool getPrintFlag() const {
+        return m_print;
+    }
+
+    void setServerAddr(const string& addr) {
+        m_server_addr = addr;
+    }
+
+    const string& getServerAddr() const {
+        return m_server_addr;
+    }
+
     /**
      * 增加收到 Spot 数据时的处理函数
      * @note 仅能在停止状态时执行此操作，否则将抛出异常
@@ -106,15 +125,18 @@ private:
     enum STATUS m_status = WAITING;      // 当前内部状态
     std::atomic_bool m_stop = true;      // 结束代理工作标识
 
-    int m_revTimeout = 100;       // 连接数据服务超时时长（毫秒）
-    size_t m_batch_count = 0;     // 记录本次批次接收的数据数量
-    std::thread m_receiveThread;  // 数据接收线程
-    ThreadPool m_tg;              // 数据处理任务线程池
+    int m_revTimeout = 100;            // 连接数据服务超时时长（毫秒）
+    size_t m_batch_count = 0;          // 记录本次批次接收的数据数量
+    std::thread m_receiveThread;       // 数据接收线程
+    std::unique_ptr<ThreadPool> m_tg;  // 数据处理任务线程池
+    size_t m_work_num = 1;             // 数据处理任务线程池线程数
     vector<std::future<void>> m_process_task_list;
 
+    bool m_print = true;   // 是否打印连接信息
+    string m_server_addr;  // 服务器地址
+
     // 下面属性被修改时需要加锁，以便可以使用多线程方式运行 strategy
     std::mutex m_mutex;
-    bool m_print = true;  // 是否打印接收进度，防止的交互模式的影响
     list<std::function<void(const SpotRecord&)>> m_processList;  // 已注册的 spot 处理函数列表
     list<std::function<void(Datetime)>> m_postProcessList;  // 已注册的批次后处理函数列表
 };