Mutex - на чистом WinAPI - библиотека для MetaTrader 5

Для чего это нужно

Глобальные переменные, файлы на диске, в памяти, важный порядок действий - теперь нет проблем!

Если вы используете:

• обращение к одним и тем же данным из разных экспертов;
  
• взаимодействуете из MQL в общих данных с другими приложениями;
  
• у вас работают копировщики на разных терминалах MT4-MT4 / MT4-MT5 / MT5-MT5 (Urain привет :)
• либо просто нужно соблюдать четкий порядок действий между разными экспертами одного или разных терминалов.
  

то вы понимаете как важно, чтобы исполняемые алгоритмы одновременно не обращались к одним и тем же данным через разные процессы.

Ибо это может привести к непредсказуемым последствиям - один процесс пишет, а второй в это же время читает и принимает некое решение и тоже обновляет эти же данные.

В этой ситуации недописанность данных первым процессом может нежелательным образом сказаться на результате решения второго и, как следствие, привести к их порче.

Решение

Используем объекты операционной системы - Mutual Exclusion. Или иным словами Mutex.

Как это работает

Механизм работы с Mutex очень прост. Используется принцип аналогичный из этой статьи - захват ресурса при создании объекта и освобождение ресурса при удалении объекта.

Работа с Mutex выполнена в виде двух классов.

• Первый класс CMutexSync - это сам ресурс-хендл Mutex, который создается и освобождается этим классом. Объект данного класса может быть глобальным и единственным на всё приложение.
• Второй класс CMutexLock - это объект захвата, который ждет освобождения и захватывает хендл Mutex при своем создании и освобождает его при своем удалении.

Дело в том, что объект захвата CMutexLock освобождает ресурс Mutex и удаляется при выходе из скобки '}'. Этим и достигается необходимая гибкость подхода.

//------------------------------------------------------------------    class CMutexSync
class CMutexSync
{
  HANDLE64 m_mutex; // дескриптор создаваемого мютекса

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; // дескриптор захватываемого мютекса

public:
  CMutexLock(CMutexSync &m, DWORD dwWaitMsec) { m_mutex=m.Get(); const DWORD res=WaitForSingleObjectX(m_mutex, dwWaitMsec); } // занимаем мютекс при конструировании объекта
  ~CMutexLock() { ReleaseMutexX(m_mutex); } // освобождаем мютекс при удалении объекта
};

Благодаря принципу захвата при создании применение Mutex делает код красивым и читаемым. Избавляет код от WinAPI функций

Пример

В этом примере - мы синхронизируем работу циклов двух скриптов на двух чартах.

Первый скрипт выполняет некие операции очень долго (в примере 2 сек.), второй скрипт выполняет свои операции быстро (0,2 сек.).

Наша задача - не дать выполнится новой итерации второго быстрого скрипта, пока первый скрипт не завершил свою текущую итерацию.

input int sleep=200;

//------------------------------------------------------------------
void OnStart()
{
        Sleep(5000); // подождем , чтоб успели кинуть скрипт на второй чарт
        CMutexSync sync; // сам объект синронизации
        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); // лочим участок в этих скобках цикла // тут и происходит ожидание и захват мютекса
                Print(Symbol()+" lock scope"); Sleep(sleep);
        }
}

Результат

32/64 Ready

Библиотека работает с учетом 32/64 битности по аналогии как в MemMap.

Удачи и профита!