Mutex - en una WinAPI pura - librería para MetaTrader 5

Para qué lo necesitamos

¡Las variables globales, los archivos en el disco o mapeados en la memoria, los procedimientos operativos de importancia: ahora nada es un problema!

Si usted:

• recurre a los mismos datos desde diferentes expertos;
  
• interactúa con otras aplicaciones desde MQL en los datos generales;
  
• tiene copiadores en diferentes terminales MT4-MT4 / MT4-MT5 / MT5-MT5 (Hola, Urain :)
• o bien simplemente tiene que respetar un orden de acciones concreto entre diferentes expertos de uno o varios terminales.
  

entonces, usted entiende lo importante que es que los algoritmos ejecutados no recurran simultáneamente a los mismos datos a través de procesos diferentes.

Y es que esto puede conducir a consecuencias impredecibles: mientras que un proceso escribe, el segundo al mismo tiempo lee y toma una cierta decisión y también actualiza estos mismos datos.

En esta situación, si el primer proceso no ha finalizado con la escritura de datos, puede influir de forma negativa en la decisión del segundo y, como consecuencia, provocar la corrupcción de los datos.

Solución

Utilizamos los objetos del sistema operativo: Mutual Exclusion. O, en otras palabras, Mutex.

Cómo funciona esto

El mecanismo de trabajo con Mutex es muy sencillo. Se usa un principio análogo al descrito en este artículo, el acaparamiento de un recurso cuando un objeto es creado y la liberación de un recurso cuando se elimina el objeto.

El trabajo con Mutex se ha realizado en dos clases.

• La primera clase, CMutexSync , es el propio recurso-manejador Mutex, que es creado y liberado por esta clase. Un objeto de esta clase puede ser global y único en toda la aplicación.
• La segunda clase, CMutexLock , es el objeto que se acapara. Este espera su liberación y luego acapara el manejador Mutex al ser creado, liberándolo al ser eliminado.

El asunto es que el objeto acaparado CMutexLock libera el recurso Mutex y es eliminado al salir de la comilla '}'. Con ayuda de ello, se logra la flexibilidad de enfoque necesaria.

//------------------------------------------------------------------    class CMutexSync

class CMutexSync

{

  HANDLE64 m_mutex; // descriptor del mutex creado

public:

        CMutexSync() { m_mutex=NULL; }

        virtual ~CMutexSync() { Destroy(); }

        bool Create(LPCTSTR name) { m_mutex=CreateMutexWX(0, false, name); return(m_mutex!=NULL); }

        void Destroy() { CloseHandleX(m_mutex); m_mutex=NULL; }

        HANDLE64 Get() const { return(m_mutex); }

};

//------------------------------------------------------------------    class CMutexLock

class CMutexLock

{

  HANDLE64 m_mutex; // descriptor del mutex acaparado

public:

  CMutexLock(CMutexSync &m, DWORD dwWaitMsec) { m_mutex=m.Get(); const DWORD res=WaitForSingleObjectX(m_mutex, dwWaitMsec); } // ocupamos el mutex al construir el objeto

  ~CMutexLock() { ReleaseMutexX(m_mutex); } // liberamos el mutex al eliminar el objeto

};

Gracias al principio de acaparamiento durante la creación de objetos, el uso de Mutex hace el código bonito y legible. Libera el código de funciones WinAPI

Ejemplo

En este ejemplo sincronizaremos el funcionamiento de los ciclos de dos scripts en dos gráficas.

El primer script ejecuta ciertas operaciones durante mucho tiempo (en el ejemplo, 2 seg.), el segundo script ejecuta las operaciones rápido (0,2 seg.).

Nuestra tarea es no dejar que se cumpla una nueva iteración del segundo script rápido, mientras el primer script no haya ejecutado su iteración actual.

input int sleep=200;

//------------------------------------------------------------------

void OnStart()

{

        Sleep(5000); // esperaremos a que dé tiempo de poner el script en la segunda gráfica

        CMutexSync sync; // el propio objeto de la sincronización

        if (!sync.Create("Local\\test")) { Print(Symbol()+" MutexSync create ERROR!"); return; }

        Print(Symbol()+" MutexSync created OK! Sleep=", sleep);

        for (int i=0; i<10; i++)

        {

                CMutexLock lock(sync, (DWORD)INFINITE); // bloqueamos un segmento en estas comillas del ciclo // aquí tiene lugar precisamente el acaparamiento del mutex

                Print(Symbol()+" lock scope"); Sleep(sleep);

        }

}

Resultado

32/64 Ready

La biblioteca funciona teniendo en cuenta la presencia de 32/64 bits, por analogía con MemMap.

¡Les deseo suerte y ganancias!