Mutex - WinAPI - biblioteca para MetaTrader 5

Porque isso é necessário

As variáveis ​​globais, arquivos de disco ou de memória mapeada, procedimentos operacionais importantes não são mais um problema!

Se você usar:

• chamadas para os mesmos dados a partir de diferente Experts
  
• trabalhar com outras aplicações em MQL em dados gerais
  
• seus copiadores trabalham em vários terminais MT4-MT4 / MT4-MT5 / MT5-MT5 (Olá, Urain :)
• ou você só precisa cumprir com os procedimentos operacionais exatos entre diferentes experts de um ou diferentes terminais,
  

você deve entender o quão importante são os algoritmos executados não recorrerem em simultâneo aos mesmos dados através de processos diferentes. Como isso pode resultar em efeitos inesperados: um processo é escrito, e outro é realizado a leitura fazendo alguma decisão, e renovando esses dados ao mesmo tempo.

Em tal caso, se a gravação dos dados pelo primeiro processo não for terminado, pode acontecer de levar a um trabalho incorreto do segundo processo, como resultado, os dados podem ser danificados.

A solução

Nós usamos os objetos do sistema operacional: Mutual Exclusion, em outras palavras o Mutex.

Como ele funciona

O Mutex é muito simples. Nós usamos um princípio semelhante ao descrito neste artigo: bloqueio de um recurso quando um objeto é criado, e desalocação de um recurso quando um objeto é removido.

O Mutex é implementado em duas classes.

• A primeira classe - CMutexSync - representa o recurso do manipulador Mutex, que é criado e desatribuído por esta classe. Um objeto desta classe pode ser global e para toda a aplicação.
• A segunda classe - CMutexLock - é um objeto bloqueado que aguarda para desalocação e bloqueia o manipulador Mutex quando criado, e desaloca quando removido.

O fato é que o CMutexLock libera o recurso Mutex e é excluído após o '}'. A flexibilidade necessária é obtida desta forma

//------------------------------------------------------------------    class CMutexSync
class CMutexSync
{
  HANDLE64 m_mutex; // descritor do mutex criado

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; // descritor do mutex bloqueado

public:
  CMutexLock(CMutexSync &m, DWORD dwWaitMsec) { m_mutex=m.Get(); const DWORD res=WaitForSingleObjectX(m_mutex, dwWaitMsec); } // captura do mutex no processo de construção do objeto
  ~CMutexLock() { ReleaseMutexX(m_mutex); } // desaloca o mutex quando o objeto é removido
};

Devido ao princípio de bloqueio do Mutex, ele torna o código bonito e legível. Ele livra o código das funções WinAPI

Exemplo

Neste exemplo, nós vamos sincronizar o funcionamento de ciclos de dois scripts em dois gráficos.

O primeiro script realiza algumas operações por muito tempo (2 segundos no exemplo). O segundo script executa suas operações de forma rápida (0,2 segundos).

Nossa tarefa é não permitir uma nova iteração no script rápido até que o primeiro script complete a sua iteração atual.

input int sleep=200;

//------------------------------------------------------------------
void OnStart()
{
        Sleep(5000); // espera até que o script esteja no segundo gráfico
        CMutexSync sync; // o objeto da sincronização
        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); // Bloqueia um segmento neste intervalo do ciclo // aqui acontece a espera e o bloqueio do mutex
                Print(Symbol()+" lock scope"); Sleep(sleep);
        }
}

Resultado

32/64 Ready

A biblioteca funciona, levando em conta a contagem de 32/64 bit de uma forma semelhante ao memmap.

Desejo-lhe boa sorte e grandes lucros!