Nouveau : la formation trading algorithmique MQL5, MQL4 et ProRealTimeDécouvrir →

MQL4 · Codes d’erreur

Erreur 146 en MQL4 (ERR_TRADE_CONTEXT_BUSY) : plusieurs EA et un seul fil de trading

L’erreur 146 survient quand un autre programme du terminal utilise déjà le fil de trading. IsTradeContextBusy, attente bornée et sémaphore : comment faire cohabiter plusieurs EA sur MetaTrader 4.

Mis à jour le 23 octobre 2026Lecture : 8 minPar Alix, OptiBot Trading

L’erreur 146, constante ERR_TRADE_CONTEXT_BUSY, libellé officiel *Trade context is busy*, signifie que le fil de trading du terminal est déjà occupé par un autre programme au moment où votre EA tente une opération. Dans MetaTrader 4, les fonctions qui envoient des requêtes de trading (OrderSend, OrderModify, OrderClose, OrderCloseBy, OrderDelete) passent par un contexte de trading unique. Tant qu’un programme attend la réponse du serveur, un autre programme ne peut pas en envoyer une nouvelle.

La documentation de IsTradeContextBusy() le formule simplement : la fonction renvoie true lorsqu’un fil de trading est occupé par un autre Expert Advisor. L’erreur 146 est donc typique des terminaux sur lesquels plusieurs EA tournent en même temps, par exemple un EA par paire de devises. L’angle de cette page est la cohabitation entre programmes : attendre proprement, éviter les collisions, et savoir quand l’architecture elle-même pose problème.

Pourquoi un seul fil de trading ?

Une requête de trading n’est pas instantanée : le terminal l’envoie au serveur, qui la vérifie, l’exécute et renvoie le résultat. Selon la latence et le mode d’exécution, cela peut prendre de quelques dizaines de millisecondes à plusieurs secondes. Pendant ce temps, le contexte de trading est réservé. Si deux EA reçoivent un tick au même moment et décident tous deux d’agir, le premier obtient le contexte, le second reçoit l’erreur 146.

Plus le nombre d’EA est élevé et plus leurs décisions sont synchrones (même signal à la clôture d’une bougie sur plusieurs symboles, par exemple), plus les collisions sont fréquentes. Le phénomène est très visible à l’ouverture des bougies horaires ou quotidiennes, lorsque tous les EA évaluent leur signal au premier tick.

Les fonctions utiles

FonctionRôle
IsTradeContextBusy()true si le fil de trading est occupé par un autre EA
IsTradeAllowed()true si l’EA est autorisé à trader et si le contexte n’est pas occupé
RefreshRates()Actualise les prix après une attente
IsStopped()true si le programme doit s’arrêter : à tester dans toute boucle d’attente
GlobalVariableSetOnCondition()Modifie une variable globale du terminal seulement si elle a la valeur attendue

La documentation de IsTradeAllowed() précise que sa forme sans paramètre vérifie à la fois l’autorisation de trading de l’EA et la disponibilité du contexte. C’est pourquoi beaucoup de codes d’attente utilisent cette fonction plutôt que IsTradeContextBusy() seule.

Attendre que le contexte se libère

La solution de base consiste à attendre, juste avant l’envoi, que le contexte soit libre, avec une limite de temps. Après l’attente, il est indispensable d’appeler RefreshRates() : les prix lus avant l’attente sont probablement périmés, et les utiliser provoquerait une erreur 138 ou une erreur 129.

//+------------------------------------------------------------------+
//| Attente bornée du contexte de trading                            |
//+------------------------------------------------------------------+
#property strict

input int InpContextTimeoutMs = 10000;   // attente maximale (ms)
input int InpPollMs           = 100;     // intervalle de contrôle (ms)

//--- true quand le contexte est libre et l'EA autorisé, false si délai dépassé
bool WaitTradeContext()
  {
   uint start = GetTickCount();
   while(IsTradeContextBusy() || !IsTradeAllowed())
     {
      if(IsStopped())
         return false;                                   // EA retiré du graphique
      if(GetTickCount() - start > (uint)InpContextTimeoutMs)
        {
         Print("Contexte de trading toujours occupé : abandon");
         return false;
        }
      Sleep(InpPollMs);
     }
   RefreshRates();                                       // prix à jour après l'attente
   return true;
  }

//--- exemple : envoi d'un achat après attente du contexte
int BuyWhenFree(const double lots, const int slippage, const int magic)
  {
   for(int attempt = 1; attempt <= 3; attempt++)
     {
      if(!WaitTradeContext())
         return -1;
      ResetLastError();
      int ticket = OrderSend(Symbol(), OP_BUY, lots, NormalizeDouble(Ask, Digits),
                             slippage, 0, 0, "", magic, 0, clrNONE);
      if(ticket >= 0)
         return ticket;
      int err = GetLastError();
      PrintFormat("Essai %d : erreur %d", attempt, err);
      if(err != 146)                                     // une autre erreur : on sort
         return -1;
     }
   return -1;
  }

Attention : si l’EA n’est pas autorisé à trader (option « Allow live trading » décochée), IsTradeAllowed() reste à false et la boucle attend jusqu’au délai maximal. Ce cas relève de l’erreur 4109 ; vérifiez l’autorisation une fois au démarrage pour ne pas confondre les deux situations.

GetTickCount() renvoie un nombre de millisecondes depuis le démarrage du système ; il sert ici à mesurer le temps écoulé indépendamment des ticks du marché.

Aller plus loin : un sémaphore entre EA

L’attente résout la plupart des cas, mais elle laisse une fenêtre : deux EA peuvent constater en même temps que le contexte est libre, puis envoyer leur ordre presque simultanément. Pour les terminaux qui font tourner de nombreux EA, une technique consiste à utiliser une variable globale du terminal comme verrou. GlobalVariableSetOnCondition(nom, valeur, valeur_attendue) modifie la variable uniquement si sa valeur actuelle est celle attendue, en une seule opération : un seul EA peut donc « prendre » le verrou.

Le principe est le suivant : avant de trader, l’EA tente de passer la variable de 0 à 1 ; s’il réussit, il trade puis remet la variable à 0 ; s’il échoue, il attend et réessaie. Il faut créer la variable si elle n’existe pas (avec GlobalVariableCheck et GlobalVariableSet), et surtout toujours libérer le verrou, y compris après une erreur, sans quoi tous les EA restent bloqués. Une sécurité courante consiste à enregistrer l’heure de prise du verrou et à le considérer comme abandonné au-delà d’un certain délai. Les variables globales du terminal sont présentées plus en détail dans la rubrique Expert Advisors.

Cas d’usage en trading

Plusieurs EA ou un seul EA multi-paires ?

Lorsque dix graphiques font tourner dix copies du même EA, les collisions sont structurelles. Une alternative consiste à écrire un seul EA qui gère plusieurs symboles depuis un graphique : les ordres sont alors envoyés les uns après les autres par le même programme, sans compétition pour le contexte. Cette architecture a ses propres contraintes, détaillées dans EA multi-paires en MQL4.

Désynchroniser les décisions

Si plusieurs EA évaluent leur signal à l’ouverture d’une bougie, ils entrent en compétition au même instant. Décaler légèrement le moment de décision, ou laisser chaque EA traiter son signal au premier tick suivant où le contexte est libre, réduit la contention.

Les fermetures d’urgence

Une fermeture de toutes les positions, déclenchée par une limite de perte par exemple, peut entrer en collision avec un autre EA qui ouvre une position. Donnez aux routines de fermeture un délai d’attente plus long que celui des ouvertures, et journalisez tout abandon. La méthode de lecture et de journalisation des codes est décrite dans GetLastError en MQL4, et l’ensemble des erreurs sur Codes d’erreur MQL4.

Le testeur ne reproduit pas l’erreur

Dans le testeur de stratégie, un seul EA s’exécute : l’erreur 146 n’y apparaît pas. Testez la cohabitation de vos EA en démonstration, dans la configuration réelle (même nombre de graphiques, mêmes symboles).

Un EA bloqué en attente du contexte de trading ne peut ni ouvrir ni fermer de position. Limitez toujours la durée d’attente et surveillez le journal lorsque plusieurs programmes tradent le même compte. Le trading comporte un risque de perte en capital.

Questions fréquentes

Que signifie « trade context is busy » ?

Que le fil de trading du terminal est occupé par un autre programme, qui attend la réponse du serveur à sa propre requête. Votre EA doit attendre que ce fil se libère avant d’envoyer la sienne.

Comment éviter l’erreur 146 ?

En attendant, avant chaque envoi, que IsTradeContextBusy() renvoie false, avec un délai maximal, puis en appelant RefreshRates(). Pour de nombreux EA simultanés, un verrou par variable globale du terminal ou un EA multi-paires unique réduit encore les collisions.

Pourquoi appeler RefreshRates après l’attente ?

Parce que les variables Bid et Ask conservent la valeur lue au début de OnTick(). Après une attente, ces prix sont souvent périmés et provoqueraient une recotation ou un prix invalide.

L’erreur 146 peut-elle apparaître avec un seul EA ?

C’est rare, car un même programme envoie ses requêtes l’une après l’autre. Elle peut toutefois survenir si un script ou un autre programme trade en même temps sur le même terminal.

Quelle différence entre IsTradeContextBusy et IsTradeAllowed ?

IsTradeContextBusy() ne teste que l’occupation du fil de trading. IsTradeAllowed() sans paramètre vérifie en plus que l’EA est autorisé à trader. Pour une attente avant envoi, les deux conditions sont utiles.

A

Alix · fondateur d’OptiBot Trading

Développeur MQL5 et ProBuilder, spécialiste du backtest et de l’optimisation de stratégies automatiques. Chaque contenu est vérifié sur la documentation officielle (MQL5.com, manuels ProRealTime) et testé avant publication. Notre méthode éditoriale.