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

Este código se encuentra en el script adjunto "sGVTestFlush". 

Me gustaría demostrar el efecto del trabajo de la función GlobalVariableFlush(). Sin embargo, durante los experimentos con el cierre de emergencia del terminal no se ha conseguido que las variables globales desaparezcan. El terminal se cerraba a través del Administrador de tareas, la pestaña «Procesos». Puede que las variables globales desaparezcan al cortar bruscamente la corriente del ordenador. Actualmente, el corte de la energía del ordenador es un hecho muy raro, ya que la mayoría de los usuarios tienen los ordenadores portátiles, en los ordenadores de sobremesa se utilizan los sistemas de alimentación interrumpida (UPS en inglés), y si el terminal trabaja en un servidor especialmente asignado, ahí más aun se toman todas las medidas necesarias para asegurar la alimentación interrumpida. Por eso incluso sin la función GlobalVariableFlush(), las variables globales es un medio bastante seguro para guardar los datos.    

Variable temporal, función GlobalVariableTemp

La función GlobalVariableTemp() se encarga de la creación de una variable global temporal (que va a existir sólo hasta el fin del trabajo del terminal). Durante varios años del desarrollo de los expertos en MQL5, el autor de este artículo nunca tuvo la necesidad de usar este tipo de variable. Es más, el mismo fenómeno de la variable global temporal contradice al principio principal por el cual ellas se utilizan: para el almacenamiento prolongado de datos independientemente del reinicio del terminal. Pero dado que esta función está presente en el lenguaje MQL5, vamos a prestarle un poco de atención por si alguien la necesite.

Cuando se invoca la función, ella recibe un parámetro, nombre de la variable. Si la variable con este nombre no existe, será creada la variable temporal con el valor 0. Después de eso, hay que asignarle un valor usando la función GlobalVariableSet(), y continuación usarla como siempre. Si la variable ya existía (fue creada antes por la función GlobalVariableSet()), no va a convertirse en la variable temporal:

   GlobalVariableSet("test",1.2); // establecimiento del valor para la variable para asegurarse de que esta variable existe
   GlobalVariableTemp("temp"); // creación de la variable temporal
   Alert("Valor de la variable temp inmediatamente después de la creación - ",GlobalVariableGet("temp"));
   GlobalVariableSet("temp",3.4); // establecimiento del valor de la variable temporal
   GlobalVariableTemp("test"); // intento de convertir la variable "test" en la temporal

Este ejemplo se encuentra en el script adjunto "sGVTestTemp". Después de iniciar el script, abra la ventana de variables globales, debe contener la variable "temp" con el valor 3.4 y "test" con el valor 1.2. Cierra la ventana de variables globales, reinicie el terminal y vuelva a abrir la ventana. La variable "test" se guardará, y la variable "temp" desaparecerá.

Cambiar la variable según la condición, función GlobalVariableSetOnCondition

Nos queda analizar la última función, según mi opinión es la más interesante: GlobalVariableSetOnCondition(). Esta función recibe tres parámetros: nombre, nuevo valor y condición de control. Si la variable tiene el valor igual al valor de control, se le asigna un valor nuevo y la función devuelve true, de lo contrario devuelve false (además, false se devuelve si la variable no existe).

Según el principio de su funcionamiento, la función es idéntica al siguiente código:

   double check_value=1;
   double value=2;

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

Si el valor de la variable global "test" es igual al valor check_value, se le establece el valor value y se devuelve el valor true, de lo contrario se devuelve el valor false. La variable check_value tiene el valor predefinido 1, para que en caso de la ausencia de la variable "test" la construcción devolvería el valor false.

La finalidad principal de la función GlobalVariableSetOnCondition() consiste en asegurar la ejecución de varios expertos. Puesto que el sistema operativo moderno es de multi tareas, y cada experto representa un flujo separado, no hay seguridad de que un experto ejecute de golpe todo su trabajo desde el principio hasta el final, luego lo mismo hará el segundo experto, etc.

El que antes manejaba el terminal MetaTrader 4, puede recordar el fenómeno como flujo comercial. Ahora varios expertos pueden enviar simultáneamente las órdenes comerciales al servidor, antes sólo un experto podía enviar la orden en un momento dado. Si en el terminal trabajaban varios expertos, al intentar realizar las operaciones comerciales, a menudo surgía el error de ocupación del flujo comercial. Al abrir y cerrar las órdenes, este error no causaba muchas molestias. Un experto escrito correctamente repetirá el intento de la apertura y cierre de la posición, además la coincidencia de los momentos de la apertura y cierre en diferentes expertos no es un caso frecuente. Si la función del Trailing stop (se tiene en cuenta la función en el experto, y no la función estándar del terminal) se activaba en varios expertos, en un tiket sólo de un experto se conseguía ejecutar la modificación del Stop Loss, y eso ya era un problema. A pesar de la ausencia de este problema actualmente, igualmente pueden aparecer las tareas que requieren la ejecución consecutiva de algunos expertos. 

Para asegurar el trabajo consecutivo de un grupo de expertos, utilizamos la variable global en cuestión. En el principio de la ejecución de la función OnTick() vamos a establecer al valor value para la variable. Después de comprobar el valor de la variable y ver el valor value en ella, otros expertos comprenderán que algún experto ya está trabajando y detendrán la ejecución de sus funciones OnTick() o entrarán en el ciclo de espera. Después de terminar todas las acciones del experto, vamos a establecer el valor check_value para la variable. Ahora otro experto podrá iniciar la ejecución de su función OnTick(), etc.

En principio, el código arriba mencionado conviene para la solución de esta tarea, pero no da seguridad de que después de la ejecución de la línea:

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

va a ejecutarse en seguida la línea: 

GlobalVariableSet("test",value);

Es muy probable que entre ellas «se meta» otro experto, «vea» que la variable tiene el valor check_value, empiece su trabajo, ejecute una parte, pero en este momento el primer experto continúe su trabajo. De esta manera, prácticamente dos expertos van a trabajar en paralelo. Pues, para solucionar precisamente este problema, se necesita la función GlobalVariableSetOnCondition(). Como se indica en el Manual de referencia, "la función proporciona el acceso atómico a una variable global". Atómico significa «indivisible». Eso significa que entre la comprobación del valor de la variable y el establecimiento del nuevo valor para ella no se meterá ningún otro programa sí o sí.

El inconveniente a la hora de usar esta función consiste en que ella no crea por sí misma la variable si ésta no existe. Entonces, hay que realizar una comprobación adicional (es deseable hacerlo al inicializar el experto) y crear la variable. 

Escribiremos dos expertos para nuestra prueba. Ambos expertos son absolutamente idénticos, al principio de la función OnTick() se abre la ventana con el mensaje "Inicio de EA1", se hace una pausa de tres segundos (a través de la función Sleep()), al final se muestra el mensaje "Fin de EA1":

void OnTick(){
   Alert("Inicio de EA1");   
   Sleep(3000);   
   Alert("Fin de EA1");
}

El segundo experto es igual, lo único que los mensajes van a ser diferentes: "Inicio de EA2" y "Fin de EA2". En los archivos adjuntos estos expertos tienen los siguientes nombres: "eGVTestEA1" y "eGVTestEA2". Abra dos gráficos iguales en el terminal y adjunte dos expertos a ellos. En la ventana informativa vemos que los expertos empiezan y terminan el trabajo al mismo tiempo, es decir trabajan en paralelo (Fig. 8).

Fig. 8. Mensajes de los expertos sobre el comienzo y el fin de la ejecución de la función OnTick()

Ahora aplicaremos la función GlobalVariableSetOnCondition() para garantizar el trabajo consecutivo de los expertos. El retoque va a ser absolutamente idéntico para ambos expertos, por eso vamos a escribir el código en un archivo incluido. En el anexo, este archivo tendrá el nombre "GVTestMutex.mqh".

Vamos a ver las funciones del archivo "GVTestMutex.mqh". Al inicializar el experto, hay que comprobar la existencia de la variable global, crearla si es necesario (función Mutex_Init()), la función va a recibir el único parámetro, nombre de la variable:

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

La segunda función es la del control: Mutex_Check(). En esta función va a ejecutarse el ciclo con la espera de la liberación de la variable global. En cuanto la variable quede libre, la función devolverá true y el experto continuará la ejecución de su función OnTick(). Si no se consigue esperar la liberación de la variable, la función devolverá false, y habrá que interrumpir la ejecución de la función OnTick():

bool Mutex_Check(string name,int timeout){   
   datetime end_time=TimeLocal()+timeout; // hora del fin de la espera
   while(TimeLocal()<end_time){ // ciclo durante el tiempo establecido
      if(IsStopped()){
         return(false); // si el experto se quita del gráfico
      }
      if(GlobalVariableSetOnCondition(name,1,0)){ 
         return(true);
      }
      Sleep(1); // pequeña pausa
   }   
   return(false); // no se ha conseguido esperar la liberación
}

La función recibe el nombre de la variable global y el tiempo de espera en segundos.

La tercera función es Mutex_Release(). En ella se establece el valor 0 para la variable global, es decir «desenganche», para que otros expertos puedan empezar su trabajo:

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

Hagamos la copia de un experto, incluyamos el archivo en él, añadiéndole la llamada a las funciones. La variable tendrá el nombre "mutex_test", vamos a llamar a la función Mutex_Check() con el tiempo de espera (time-out) de 30 segundos. A continuación se muestra el código completo del experto:

#include <GVTestMutex.mqh>

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

void OnTick(){

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

   Alert("Inicio de EA1");
   Sleep(3000);
   Alert("Fin de EA1");

   Mutex_Release("mutex_test");

}

Hagamos la copia de este experto y editemos el texto de mensajes a mostrar. En los archivos adjuntos estos expertos tienen los siguientes nombres: "eGVTestEA1-2" y "eGVTestEA2-2". Vamos a iniciar estos expertos en dos gráficos similares, vemos que ahora trabajan turnándose (Fig. 9).

 
Fig. 9. Expertos trabajan turnándose

Clase para un trabajo cómodo con las variables globales

class CGlobalVariables{
   private:
      string m_common_prefix; // prefijo para las variables comunes
      string m_order_prefix; // prefijo para las variables de las órdenes
   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);
} 

//--- para variables comunes
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); 
}
//--- para variables comunes de las órdenes
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);