MT5多品种多周期(MS/MT)EA实战：从内存泄漏到并发优化的全链路调优

// 错误示范：每次Tick都创建新的指标句柄，从不释放
void OnTick()
{
   // 获取EURUSD的H1 MA值
   int ma_handle = iMA("EURUSD", PERIOD_H1, 20, 0, MODE_SMA, PRICE_CLOSE);
   double ma_buffer[];
   CopyBuffer(ma_handle, 0, 0, 1, ma_buffer);
   // 使用 ma_buffer[0] 做交易决策...
   
   // 再获取GBPUSD的H1 RSI值
   int rsi_handle = iRSI("GBPUSD", PERIOD_H1, 14, PRICE_CLOSE);
   double rsi_buffer[];
   CopyBuffer(rsi_handle, 0, 0, 1, rsi_buffer);
   // 使用 rsi_buffer[0] 做交易决策...
}

// 正确示范：全局创建 + 析构释放
input string Symbols[] = {"EURUSD", "GBPUSD", "USDJPY"};
input ENUM_TIMEFRAMES TFs[] = {PERIOD_M15, PERIOD_H1, PERIOD_H4};

int m_ma_handles[][][];  // [symbol_index][tf_index][ma_period_index]
int m_rsi_handles[][];  // [symbol_index][tf_index]
int m_sym_count;
int m_tf_count;

int OnInit()
{
   m_sym_count = ArraySize(Symbols);
   m_tf_count  = ArraySize(TFs);
   
   // 二维数组：品种 × 周期
   ArrayResize(m_ma_handles, m_sym_count);
   ArrayResize(m_rsi_handles, m_sym_count);
   
   for(int s = 0; s < m_sym_count; s++)
   {
      ArrayResize(m_ma_handles[s], m_tf_count);
      ArrayResize(m_rsi_handles[s], m_tf_count);
      
      for(int t = 0; t < m_tf_count; t++)
      {
         // 创建MA句柄（20周期SMA）
         m_ma_handles[s][t] = iMA(Symbols[s], TFs[t], 20, 0, MODE_SMA, PRICE_CLOSE);
         if(m_ma_handles[s][t] == INVALID_HANDLE)
         {
            Print("创建MA句柄失败: ", Symbols[s], " ", EnumToString(TFs[t]));
            return INIT_FAILED;
         }
         
         // 创建RSI句柄（14周期）
         m_rsi_handles[s][t] = iRSI(Symbols[s], TFs[t], 14, PRICE_CLOSE);
         if(m_rsi_handles[s][t] == INVALID_HANDLE)
         {
            Print("创建RSI句柄失败: ", Symbols[s], " ", EnumToString(TFs[t]));
            return INIT_FAILED;
         }
      }
   }
   return INIT_SUCCEEDED;
}

void OnDeinit(const int reason)
{
   // 释放所有指标句柄
   for(int s = 0; s < m_sym_count; s++)
   {
      for(int t = 0; t < m_tf_count; t++)
      {
         if(m_ma_handles[s][t] != INVALID_HANDLE)
            IndicatorRelease(m_ma_handles[s][t]);
         if(m_rsi_handles[s][t] != INVALID_HANDLE)
            IndicatorRelease(m_rsi_handles[s][t]);
      }
   }
}

// 获取其他品种在"当前主品种K线时间"对应的K线索引
// symbol: 目标品种名称
// tf: 目标周期
// ref_time: 基准时间戳（主品种当前K线的开盘时间）
// 返回值: 目标品种中时间戳等于ref_time的K线索引，找不到返回-1
int GetAlignedBarShift(string symbol, ENUM_TIMEFRAMES tf, datetime ref_time)
{
   // exact=true: 精确匹配，找不到返回-1
   // exact=false: 返回最近的K线索引（可能引入未来函数！）
   int shift = iBarShift(symbol, tf, ref_time, true);
   return shift;
}

// 安全的时间戳对齐函数：向历史方向查找最近的K线
// 确保不会使用未来数据
int GetSafeBarShift(string symbol, ENUM_TIMEFRAMES tf, datetime ref_time)
{
   // 先尝试精确匹配
   int shift = iBarShift(symbol, tf, ref_time, true);
   if(shift >= 0) return shift;
   
   // 精确匹配失败，向历史方向查找（shift值更大 = 更久远）
   // 先获取离ref_time最近的K线（不管前后）
   int nearest = iBarShift(symbol, tf, ref_time, false);
   if(nearest < 0) return -1;
   
   // 检查这根K线的时间是否在ref_time之前或等于
   datetime bar_time = iTime(symbol, tf, nearest);
   if(bar_time <= ref_time)
   {
      // 在历史方向，安全使用
      return nearest;
   }
   else
   {
      // 在未来方向，回退一根（向历史方向）
      // 确保我们使用的是ref_time之前最近的一根
      if(nearest + 1 < iBars(symbol, tf))
         return nearest + 1;
      else
         return -1;
   }
}

// 数据缓存池类（简化版）
class CRatesCachePool
{
private:
   string          m_symbols[];
   ENUM_TIMEFRAMES m_timeframes[];
   MqlRates        m_rates[][][];    // [symbol_idx][tf_idx][bar_idx]
   datetime        m_last_update[];  // [symbol_idx * tf_count + tf_idx]
   int             m_sym_count;
   int             m_tf_count;
   int             m_cache_depth;    // 缓存深度（K线根数）
   
public:
   CRatesCachePool() : m_sym_count(0), m_tf_count(0), m_cache_depth(500) {}
   ~CRatesCachePool() {}
   
   // 初始化缓存池
   bool Init(string symbols[], ENUM_TIMEFRAMES timeframes[], int depth = 500)
   {
      m_sym_count   = ArraySize(symbols);
      m_tf_count    = ArraySize(timeframes);
      m_cache_depth = depth;
      
      // 复制品种和周期配置
      ArrayResize(m_symbols, m_sym_count);
      ArrayResize(m_timeframes, m_tf_count);
      ArrayCopy(m_symbols, symbols);
      ArrayCopy(m_timeframes, timeframes);
      
      // 三维数组：品种 × 周期 × K线
      ArrayResize(m_rates, m_sym_count);
      for(int s = 0; s < m_sym_count; s++)
      {
         ArrayResize(m_rates[s], m_tf_count);
         for(int t = 0; t < m_tf_count; t++)
         {
            ArrayResize(m_rates[s][t], m_cache_depth);
         }
      }
      
      // 初始化时间标记
      ArrayResize(m_last_update, m_sym_count * m_tf_count);
      ArrayInitialize(m_last_update, 0);
      
      // 首次全量加载
      return FullRefresh();
   }
   
   // 全量刷新所有缓存
   bool FullRefresh()
   {
      bool success = true;
      for(int s = 0; s < m_sym_count; s++)
      {
         for(int t = 0; t < m_tf_count; t++)
         {
            int copied = CopyRates(m_symbols[s], m_timeframes[t], 0, m_cache_depth, m_rates[s][t]);
            if(copied <= 0)
            {
               Print("缓存池全量刷新失败: ", m_symbols[s], " ", EnumToString(m_timeframes[t]));
               success = false;
            }
            else
            {
               m_last_update[s * m_tf_count + t] = m_rates[s][t][0].time;
            }
         }
      }
      return success;
   }
   
   // 增量更新：只更新有新K线的品种/周期
   void TickUpdate()
   {
      for(int s = 0; s < m_sym_count; s++)
      {
         for(int t = 0; t < m_tf_count; t++)
         {
            // 检查当前最新K线时间是否变化
            datetime current_time = iTime(m_symbols[s], m_timeframes[t], 0);
            int idx = s * m_tf_count + t;
            
            if(current_time != m_last_update[idx])
            {
               // 有新K线，只更新前几根（通常只需更新1-2根）
               // 因为新K线出现时，最旧的那根被挤出缓存
               int copied = CopyRates(m_symbols[s], m_timeframes[t], 0, m_cache_depth, m_rates[s][t]);
               if(copied > 0)
               {
                  m_last_update[idx] = m_rates[s][t][0].time;
               }
            }
         }
      }
   }
   
   // 获取指定品种和周期的K线数据（只读访问）
   bool GetRates(int sym_idx, int tf_idx, MqlRates &out_rates[]) const
   {
      if(sym_idx < 0 || sym_idx >= m_sym_count) return false;
      if(tf_idx  < 0 || tf_idx  >= m_tf_count)  return false;
      
      int count = ArrayCopy(out_rates, m_rates[sym_idx][tf_idx]);
      return (count > 0);
   }
   
   // 获取单根K线（最常用的快速访问）
   bool GetSingleRate(int sym_idx, int tf_idx, int shift, MqlRates &rate) const
   {
      if(sym_idx < 0 || sym_idx >= m_sym_count) return false;
      if(tf_idx  < 0 || tf_idx  >= m_tf_count)  return false;
      if(shift   < 0 || shift   >= m_cache_depth) return false;
      
      rate = m_rates[sym_idx][tf_idx][shift];
      return true;
   }
};

// 事件驱动架构示例

CRatesCachePool g_cache_pool;

int OnInit()
{
   // 初始化缓存池...
   string syms[] = {"EURUSD", "GBPUSD", "USDJPY"};
   ENUM_TIMEFRAMES tfs[] = {PERIOD_M15, PERIOD_H1, PERIOD_H4};
   g_cache_pool.Init(syms, tfs, 500);
   
   // 创建定时器，每秒触发一次
   // 用于后台数据预加载
   EventSetTimer(1);
   
   return INIT_SUCCEEDED;
}

void OnDeinit(const int reason)
{
   EventKillTimer();
}

// OnTimer：负责数据更新（异步预加载）
void OnTimer()
{
   // 更新所有品种的缓存数据
   g_cache_pool.TickUpdate();
   
   // 还可以在这里做一些非实时的计算
   // 比如：趋势强度评估、市场波动率统计等
   CalculateMarketRegime();
}

// OnTick：只负责核心交易逻辑（读缓存 + 决策 + 下单）
void OnTick()
{
   // 注意：这里不再调用CopyRates
   // 所有数据都从缓存池中读取
   
   for(int s = 0; s < SYM_COUNT; s++)
   {
      // 从缓存读取M15的最新K线
      MqlRates m15_rate;
      if(!g_cache_pool.GetSingleRate(s, 0, 1, m15_rate)) continue;
      
      // 从缓存读取H1的最新数据
      MqlRates h1_rate;
      if(!g_cache_pool.GetSingleRate(s, 1, 1, h1_rate)) continue;
      
      // 基于缓存数据做交易决策
      if(CheckEntryCondition(s, m15_rate, h1_rate))
      {
         ExecuteTrade(s, OP_BUY);
      }
   }
}

// 性能监控器类
class CPerformanceMonitor
{
private:
   string   m_prefix;          // 对象名称前缀
   int      m_indicator_count; // 指标句柄数量
   int      m_last_tick_us;    // 上次Tick耗时（微秒）
   int      m_last_data_us;    // 上次数据更新耗时
   long     m_last_mem_mb;     // 上次内存占用（MB）
   datetime m_last_check_time; // 上次检查时间
   
public:
   CPerformanceMonitor() : m_indicator_count(0), m_last_tick_us(0), 
                           m_last_data_us(0), m_last_mem_mb(0) {}
   ~CPerformanceMonitor() { ClearObjects(); }
   
   void Init(string prefix = "perf_mon_")
   {
      m_prefix = prefix;
      CreateLabelObjects();
   }
   
   // Tick开始时调用，记录起始时间
   ulong TickStart()
   {
      return GetMicrosecondCount();
   }
   
   // Tick结束时调用，计算耗时并更新显示
   void TickEnd(ulong start_time)
   {
      m_last_tick_us = (int)(GetMicrosecondCount() - start_time);
      UpdateDisplay();
   }
   
   // 记录数据获取耗时
   void SetDataUpdateTime(int us) { m_last_data_us = us; }
   
   // 设置当前指标句柄数量
   void SetIndicatorCount(int count) { m_indicator_count = count; }
   
private:
   void CreateLabelObjects()
   {
      // 创建7个标签对象显示各项指标
      // （实际代码中需要用ObjectCreate创建每个标签）
   }
   
   void UpdateDisplay()
   {
      // 每秒更新一次显示，避免频繁重绘
      datetime now = TimeCurrent();
      if(now == m_last_check_time) return;
      m_last_check_time = now;
      
      // 获取终端内存占用
      long mem_bytes = TerminalInfoInteger(TERMINAL_MEMORY_USED);
      m_last_mem_mb  = mem_bytes / (1024 * 1024);
      
      // 更新各个标签的文本
      // 内存占用、句柄数、Tick耗时、数据耗时等
   }
   
   void ClearObjects()
   {
      // 清理所有创建的图表对象
   }
};

//+------------------------------------------------------------------+
//|                                          MS_MT_Framework.mqh     |
//|                        多品种多周期EA基础框架 v1.0                |
//+------------------------------------------------------------------+
#property copyright "eafxtech.com"
#property link      "https://www.eafxtech.com"
#property version   "1.00"
#property strict

// --- 配置参数 ---
input string InpSymbols[]    = {"EURUSD", "GBPUSD", "USDJPY", "AUDUSD", "USDCAD"};
input ENUM_TIMEFRAMES InpTFs[] = {PERIOD_M15, PERIOD_H1, PERIOD_H4, PERIOD_D1};
input int    InpCacheDepth   = 500;           // 缓存深度
input int    InpTimerInterval = 1;            // 定时器间隔（秒）
input double InpRiskPerTrade = 0.01;          // 单笔风险比例
input bool   InpEnableMonitor = true;         // 启用性能监控

// --- 全局管理器实例 ---
CRatesCachePool     g_rates_cache;   // 数据缓存池
CHandleManager      g_handle_mgr;    // 句柄管理器
COrderManager       g_order_mgr;     // 订单管理器
CPerformanceMonitor g_perf_mon;      // 性能监控器
CSignalEngine       g_signal_engine; // 信号引擎

int g_sym_count;
int g_tf_count;

//+------------------------------------------------------------------+
//| 初始化函数                                                       |
//+------------------------------------------------------------------+
int OnInit()
{
   g_sym_count = ArraySize(InpSymbols);
   g_tf_count  = ArraySize(InpTFs);
   
   if(g_sym_count == 0 || g_tf_count == 0)
   {
      Print("错误：品种或周期配置为空");
      return INIT_PARAMETERS_INCORRECT;
   }
   
   // 1. 初始化数据缓存池
   if(!g_rates_cache.Init(InpSymbols, InpTFs, InpCacheDepth))
   {
      Print("数据缓存池初始化失败");
      return INIT_FAILED;
   }
   
   // 2. 初始化句柄管理器（根据需要创建指标句柄）
   if(!g_handle_mgr.Init(g_sym_count, g_tf_count))
   {
      Print("句柄管理器初始化失败");
      return INIT_FAILED;
   }
   
   // 3. 初始化订单管理器
   g_order_mgr.Init(InpRiskPerTrade);
   
   // 4. 初始化信号引擎
   g_signal_engine.Init(g_sym_count, g_tf_count);
   
   // 5. 初始化性能监控
   if(InpEnableMonitor)
   {
      g_perf_mon.Init("msmt_perf_");
      g_perf_mon.SetIndicatorCount(g_handle_mgr.GetTotalHandleCount());
   }
   
   // 6. 启动定时器（用于后台数据更新）
   EventSetTimer(InpTimerInterval);
   
   Print("MS/MT框架初始化完成: ", g_sym_count, " 个品种, ", g_tf_count, " 个周期");
   return INIT_SUCCEEDED;
}

//+------------------------------------------------------------------+
//| 析构函数                                                         |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
   EventKillTimer();
   
   // 按顺序清理资源
   g_order_mgr.Cleanup();
   g_handle_mgr.Cleanup();     // 释放所有指标句柄
   g_rates_cache.Cleanup();
   
   Print("MS/MT框架已清理，退出原因: ", reason);
}

//+------------------------------------------------------------------+
//| 定时器事件：后台数据更新 + 非实时计算                             |
//+------------------------------------------------------------------+
void OnTimer()
{
   ulong start = GetMicrosecondCount();
   
   // 更新数据缓存
   g_rates_cache.TickUpdate();
   
   // 更新指标缓冲区（如果使用了指标句柄）
   g_handle_mgr.RefreshBuffers();
   
   int elapsed = (int)(GetMicrosecondCount() - start);
   
   if(InpEnableMonitor)
      g_perf_mon.SetDataUpdateTime(elapsed);
}

//+------------------------------------------------------------------+
//| Tick事件：核心交易逻辑                                           |
//+------------------------------------------------------------------+
void OnTick()
{
   ulong tick_start = g_perf_mon.TickStart();
   
   // 遍历所有品种，检查交易信号
   for(int s = 0; s < g_sym_count; s++)
   {
      // 跳过不可交易的品种
      if(!SymbolSelect(InpSymbols[s], false)) continue;
      if(SymbolInfoInteger(InpSymbols[s], SYMBOL_TRADE_MODE) == SYMBOL_TRADE_MODE_DISABLED) continue;
      
      // 从缓存池获取关键周期的数据
      MqlRates m15_rate, h1_rate, h4_rate;
      if(!g_rates_cache.GetSingleRate(s, 0, 1, m15_rate)) continue;
      if(!g_rates_cache.GetSingleRate(s, 1, 1, h1_rate))  continue;
      if(!g_rates_cache.GetSingleRate(s, 2, 1, h4_rate))  continue;
      
      // 交给信号引擎判断
      ENUM_ORDER_TYPE signal = g_signal_engine.CheckSignal(
         s, m15_rate, h1_rate, h4_rate, g_handle_mgr);
      
      // 有信号则交给订单管理器执行
      if(signal != ORDER_TYPE_CLOSE_BY)
      {
         g_order_mgr.ExecuteSignal(InpSymbols[s], signal, m15_rate.close);
      }
   }
   
   // 监控更新
   if(InpEnableMonitor)
      g_perf_mon.TickEnd(tick_start);
}

//+------------------------------------------------------------------+
//| 交易事件：订单状态变化处理                                       |
//+------------------------------------------------------------------+
void OnTradeTransaction(const MqlTradeTransaction &trans,
                        const MqlTradeRequest &request,
                        const MqlTradeResult &result)
{
   g_order_mgr.OnTransaction(trans, request, result);
}
//+------------------------------------------------------------------+