GlobalVariableSet("gr1_var1",1.2);
   GlobalVariableSet("gr1_var2",3.4);   
   GlobalVariableSet("gr2_var1",5.6);
   GlobalVariableSet("gr2_var2",7.8);   
   
   GlobalVariablesFlush();

Das Beispiel findet sich im Skript sGVTestFlush im Anhang unten. 

Es wäre schön, die Arbeitsweise der Funktion GlobalVariableFlush() näher erläutern zu können, aber unglücklicherweise gelang es mir nicht, die globalen Variablen während eines Notfall-Endes des Terminals verschwinden zu lassen. Das Terminal wurde über das Prozess-Fenster des Task-Managers beendet. Vielleicht verschwinden die globalen Variablen im Falles eines Rechnerabsturzes. Ein erwarteter Rechnerabsturz passiert allerdings heutzutage eher selten, da die meisten Nutzer über Laptops verfügen, während die Standrechner normalerweise über eine unterbrechungsfreie Stromversorgung verfügen. Wenn ein Terminal auf einem "dedicated server" läuft, ist der Schutz vor einer Unterbrechung der Stromversorgung noch besser. Daher speichern globale Variablen ihre Daten sehr zuverlässig, auch ohne die Verwendung der Funktion GlobalVariableFlush().    

Temporäre Variablen, die Funktion GlobalVariableTemp

Die Funktion GlobalVariableTemp() erstellt eine temporäre globale Variable (sie existiert bis das Terminal geschlossen wird). In den Jahren, in denen ich EAs mit MQL5 entwickelte, habe ich noch nie eine solche Variable benötigt. Darüber hinaus widerspricht eine temporäre globale Variable eigentlich ihrem Grundkonzept — eine langfristige Datensicherung unabhängig vom (Neu-)Start des Terminals. Aber da sie nun einmal existiert, sollten wir ihr etwas Aufmerksamkeit erweisen, falls sie doch jemand benötigt.

Für den Aufruf wird dieser Funktion ein einziger Parameter — der Variablenname — übergeben. Existiert unter diesem Namen noch keine Variable, wird eine mit dem Startwert 0 angelegt. Danach kann ihr mit der Funktion GlobalVariableSet() ein Wert zugewiesen werden, so dass sie in herkömmlicher Weise verwendet werden kann. Existiert die Variable bereits (vorher erstellt mit der Funktion GlobalVariableSet()), wird diese Variable aber nicht in eine temporäre umgewandelt:

   GlobalVariableSet("test",1.2); // Setze den Wert der Variable, um sicher zu sein sie existiert
   GlobalVariableTemp("temp"); // erstelle eine temporäre Variable
   Alert("temp variable value right after creation - ",GlobalVariableGet("temp"));
   GlobalVariableSet("temp",3.4); // Setze den Wert der temporären Variablen
   GlobalVariableTemp("test"); // Versuch die die Variable "test" in eine temporäre zu ändern

Das Beispiel findet sich im Skript sGVTestTemp im Anhang unten. Nach dem Starten des Skripts öffnen wir das Fenster aller globalen Variablen. Es sollte die Variable "temp" mit dem Wert 3.4 und "test" mit 1.2 zu sehen sein. Wir schließen jetzt das Fenster und das Terminal und starten dann das Terminal und das Fenster. Die Variable "test" wurde gesichert, aber "temp" ist verschwunden.

Bedingtes Ändern einer Variablen, die Funktion GlobalVariableSetOnCondition

Jetzt ist es an der Zeit sich der letzten und, meiner Meinung nach, interessantesten Funktion zuzuwenden: GlobalVariableSetOnCondition(). Der Funktion werden drei Parameter übergeben: Name, neuere Wert und Testwert. Ist der Wert der Variablen gleich dem Testwert, wird der neue Wert gesichert und die Funktion liefert ein true, ansonsten ein false (das passiert auch, wenn die Variable nicht existiert).

Bezüglich ihrer Arbeitsweise entspricht diese Funktion dem folgenden Code:

   double check_value=1;
   double value=2;

   if(GlobalVariableGet("test")==check_value){
      GlobalVariableSet("test",value);
      return(true);
   }
   else {
      return(false);
   }

Wenn der Wert der globalen Variablen "test" gleich dem Testwert check_value ist, wird der Wert von value zugewiesen und true wird zurückgeliefert, ansonsten — false. Die Variable check_value hat einen Standardwert von 1, so dass, falls die Variable "test" nicht existiert, ebenfalls ein false zurückgegeben wird.

Das Hauptziel der Funktion GlobalVariableSetOnCondition() ist, eine geordnetes Verhalten von einander unabhängiger EAs zu ermöglichen. Da die heutigen Betriebssysteme das Multi-Tasking unterstützen und jeder EA daher im eigenen Thread läuft, kann nicht mehr garantiert werden, dass alle Aufgabe aller EAs hübsch der Reihe nach ausgeführt werden.

Wenn Sie etwas Erfahrung im Umgang mit mt4 haben, erinnern Sie sich sicher noch an die hoch ausgelasteten Handelsausführungen. Jetzt, können mehrere EAs ihre Handelsaufträge zugleich an den Server senden und die werden ausgeführt, anders als früher, als nur jeweils ein EA seinen Auftrag zu einem vorgegebenen Zeitpunkt senden konnte. Liefen mehrere EAs auf dem Terminal, traten häufiger Fehler ("trade server is busy") bei der Auftragsausführung auf, besonders bei "Marketorders". Beim Öffnen oder Schließen von Positionen waren solche Fehler nur ein Ärgernis, da gute EAs ihre Versuche eine Position zu öffnen oder schließen einfach wiederholten. Außerdem war es wohl ziemlich selten, dass ausgerechnet zum selben Zeitpunkt zwei verschiedene EAs ihre Aufträge erteilen wollten. Wenn mehrere EAs jedoch ihren Stopp kontinuierlich nachziehen sollen (als Teil der EAs, nicht des Terminals), dann konnte immer nur jeweils einer seinen Stopp ändern und das konnte schon zu Problem werden. Unabhängig davon, dass es jetzt keine solche Probleme mehr gibt, könnte es dennoch die Notwendigkeit für nacheinander abzuarbeitende Aufgaben einiger EAs geben. 

Die beschriebenen globalen Variablen können genau diesen korrekten Ablauf der Aufgaben sicherstellen. Zu Beginn der Funktion OnTick() weisen wir einen Wert der Variablen zu, so dass andere EAs erkennen können, es wird bereits gerechnet, und sie müssen entweder den Ablauf in ihrer Funktion OnTick() unterbrechen oder in eine Warteschleife eintreten. Nachdem nun der EA alles Notwendige erledigt hat, weisen wir check_value der Variablen zu, und jetzt kann ein anderer EA seine Funktion OnTick() abarbeiten, etc.

Eigentlich sollte der obige Code diese Aufgabe erledigen, aber wir können nicht garantieren, dass nach der Zeile:

if(GlobalVariableGet("test")==check_value){

sofort die folgende Zeile ausgeführt wird: 

GlobalVariableSet("test",value);

Ein anderer EA könnte sich dazwischen schalten und nach der Abfrage von check_value zu rechnen beginnen. Nachdem er seine Aufgaben teilweise erledigt hat, könnte der erste EA seine Aufgaben fortführen. So könnte es dazu kommen, dass trotzdem beide EAs zugleich arbeiten. Die Funktion GlobalVariableSetOnCondition() löst genau dies Problem. Wie in der Dokumentation beschrieben, "bietet die Funktion einen unteilbaren Zugang ("atomic access") zu der globalen Variablen". "Atomic" meint hier unteilbar. Daher kann sich kein anderes Programm während der Variablenabfrage dazwischen schalten und ihr einen neuen Wert zuweisen.

Der einzige Nachteil der Funktion ist, dass sie selber keine Variable erstellt, wenn sie nicht existiert. Das heißt, wir müssen eine zusätzlich Prüfung vornehmen (vorzugsweise während der Initialisierung) und die Variable gegebenenfalls erstellen. 

Gut, schreiben wir zwei EAs, die dieses Experiment durchführen. Beide EAs sind komplett identisch. Das Fenster mit "EA1 start" erscheint bei Beginn der Funktion OnTick() gefolgt von eine Pause von 3 Sekunden.(die Funktion Sleep()). Am Ende erscheint "EA1 end":

void OnTick(){
   Alert("EA1 start");   
   Sleep(3000);   
   Alert("EA1 end");
}

Der zweite EA ist ganz ähnlich, es sind nur die Nachrichten anders: "EA2 start" und "EA2 end". Diese EAs sind angehängt als eGVTestEA1 und eGVTestEA2. Öffnen Sie jetzt zwei identische Charts im Terminal und starten sie jeweils einen der EAs auf ihnen. Das Fenster zeigt, dass die EAs ihre Berechnungen gleichzeitig starten und beenden (Abb. 8).

Fig. 8. EA Nachrichten aus OnTick() über Start und End

Verwenden wir jetzt die Funktion GlobalVariableSetOnCondition() für ein geordnetes Verhalten beider EAs. Die zu ergänzenden Änderungen sind gleich für beide EAs, wir schreiben daher den Code in eine mit "include" zu ladende Datei. Die Datei nennen wir GVTestMutex.mqh (im Anhang unten).

Betrachten wir die Funktionen in der Datei GVTestMutex.mqh. Während der Initialisierung des EA prüfen wir, ob die globale Variable existiert, und erstellen sie, falls notwendig (die Funktion Mutex_Init()). Der Funktion wird ein einziger Parameter — der Variablennamen — übergeben:

void Init(string name){
   if(!GlobalVariableCheck(name)){
      GlobalVariableSet(name,0);
   }
}

Die zweite Funktion (Mutex_Check()) dient der Verifikation. Eine Schleife, die auf die Freigabe der globalen Variable wartet, leistet das. Sobald die Variable freigegeben wurde, returniert die Funktion true, und der EA kann mit seinen Berechnungen in der Funktion OnTick() fortfahren. Wird die Variable in der vorgegebenen Zeit nicht freigegeben, retourniert die Funktion false. In diesem Falls sollte die Funktion OnTick() unterbrochen werden:

bool Mutex_Check(string name,int timeout){   
   datetime end_time=TimeLocal()+timeout; // maximale Wartezeit
   while(TimeLocal()<end_time){ // Warteschleife
      if(IsStopped()){
         return(false); // Falls der EA vom Chart entfernt wurde
      }
      if(GlobalVariableSetOnCondition(name,1,0)){ 
         return(true);
      }
      Sleep(1); // kurze Pause
   }   
   return(false); // keine Freigabe innerhalb der vorgegeben Zeit
}

Der Name der globalen Variablen und die maximale Wartezeit in Sekunden wird der Funktion übergeben.

Die dritte Funktion ist Mutex_Release(). Sie setzt den Wert der globalen Variablen auf 0 (freigegeben), so dass andere EAs jetzt weiter rechnen können:

void Mutex_Release(string name){
   GlobalVariableSet(name,0);
}

Machen Sie eine Kopie von einem EA, laden Sie die Datei und fügen Sie den Funktionsaufruf ein. Der Name der Variablen ist "mutex_test". Rufen wir die Funktion Mutex_Check() mit einer Toleranzzeit von 30 Sekunden auf. Der ganze EA ist unten aufgeführt:

#include <GVTestMutex.mqh>

int OnInit(){
   Mutex_Init("mutex_test");
   return(INIT_SUCCEEDED);
}

void OnTick(){

   if(!Mutex_Check("mutex_test",30)){
      return;
   }

   Alert("EA1 start");
   Sleep(3000);
   Alert("EA1 end");

   Mutex_Release("mutex_test");

}

Erstellen wir eine Kopie des EA und ändern noch den Text der angezeigten Nachricht. Die beigefügten EAs heißen eGVTestEA1-2 und eGVTestEA2-2. Starten wir nun beide EAs auf jeweils identischen Charts, um zu sehen, ob sie sich jetzt selbst koordinieren können (Fig. 9).

 
Fig. 9. Beide EAs arbeiten abwechselnd

Klasse für ein einfaches Arbeiten mit globalen Variablen

class CGlobalVariables{
   private:
      string m_common_prefix; // Präfix der allgemeinen Variablen
      string m_order_prefix; // Präfix der Auftragsvariablen
   public:
      // constructor
      void CGlobalVariables(){}
      // destructor
      void ~CGlobalVariables(){}
}

void Init(string symbol,int magic){
   m_order_prefix="order_";
   m_common_prefix=MQLInfoString(MQL_PROGRAM_NAME)+"_"+symbol+"_"+IntegerToString(magic)+"_";
   if(MQLInfoInteger(MQL_TESTER)){
      m_order_prefix="tester_"+m_order_prefix;
      m_common_prefix="t_"+m_common_prefix;
      DeleteAll();
   }         
}

string Prefix(){
   return(m_common_prefix);
} 

// für allgemeine Variablen
bool Check(string name){
   return(GlobalVariableCheck(m_common_prefix+name));
}
void Set(string name,double value){
   GlobalVariableSet(m_common_prefix+name,value);      
}      
double Get(string name){
   return(GlobalVariableGet(m_common_prefix+name));
} 
void Delete(string name){
   GlobalVariableDel(m_common_prefix+name); 
}
// für die Auftragsvariablen
bool Check(ulong ticket,string name){
   return(GlobalVariableCheck(m_order_prefix+IntegerToString(ticket)+"_"+name));
}
void Set(ulong ticket,string name,double value){
   GlobalVariableSet(m_order_prefix+IntegerToString(ticket)+"_"+name,value);      
}      
double Get(ulong ticket,string name){
   return(GlobalVariableGet(m_order_prefix+IntegerToString(ticket)+"_"+name));
} 
void Delete(ulong ticket,string name){
   GlobalVariableDel(m_order_prefix+IntegerToString(ticket)+"_"+name); 
} 

GlobalVariablesDeleteAll(m_common_prefix);
GlobalVariablesDeleteAll(m_order_prefix);  

 void Deinit(){
    if(MQLInfoInteger(MQL_TESTER)){
        DeleteByPrefix();
    }
 }

void Flush(){
   GlobalVariablesFlush();
}

void DeleteByPrefix(string prefix){
   GlobalVariablesDeleteAll(m_common_prefix+prefix);
}

#include <CGlobalVariables.mqh>

CGlobalVariables gv;

gv.Init(Symbol(),123);

gv.Deinit();

   gv.Set("name1",123.456);
   double val=gv.Get("name1");

void CGlobalVariables(string symbol="",int magic=0){
   Init(symbol,magic);
}
// destructor
void ~CGlobalVariables(){
   Deinit();
}

CGlobalVariables gv(Symbol(),123);