Mutex - WinAPI - Bibliothek für den MetaTrader 5

Warum dies notwendig ist

Globale Variablen, Festplatte oder im Speicher abgelegte Dateien (memory-mapped files), wichtige operative Verfahren sind jetzt kein Problem mehr!

Wenn Sie verwenden:

• Zugriff auf die selben Daten von verschiedenen Experten
  
• arbeiten mit anderen Anwendungen aus MQL mit gemeinsamen Daten
  
• Ihr Kopierer arbeitet mit verschiedenen MT4-MT4 / MT4-MT5 / MT5-MT5 Terminals (Hallo, Urain :)
• oder Sie müssen nur den exakten Vorgaben von anderen Experten oder sogar verschiedenen Terminals nachkommen,
  

Sie sollen verstehen, wie wichtig es ist, dass die ausgeführten Algorithmen nicht auf die gleichen Daten über unterschiedliche Prozesse gleichzeitig zugreifen. Das könnte zu unerwarteten Effekten führen: Ein Prozess schreibt ein anderer liest und trifft Entscheidungen und erneuert die Daten gleichzeitig.

Wenn jetzt das Schreiben der Daten durch den ersten Prozess noch nicht beendet wurde, könnte es in einem solchen Fall zu eine fehlerhaften Ausführung des zweiten Prozesses kommen und die gesamten Daten beschädigen.

Die Lösung

Wir verwenden Objekte der Mutual Exclusion des Betriebssystems, in anderen Worten, Mutex.

Wie es funktioniert

Mutex ist sehr einfach. Wir verwenden ein ähnliches Prinzip wie in diesem Artikel beschrieben: eine Ressource wird gesperrt, wenn ein Objekt erstellt wird, und die Ressource wird wieder freigegeben, wenn ein Objekt entfernt wird.

Die Arbeit mit Mutex ist durch zwei Klassen implementiert.

• Das erste Klasse - CMutexSync - stellt die Handles der Mutex Ressourcen für das Erstellen und Freigeben dieser Klasse bereit. Ein Objekt dieser Klasse kann global sein, und eines für die gesamte Anwendung.
• Die zweite Klasse - CMutexLock - ist ein gesperrtes Objekt, das auf die Freigabe wartet, es sperrt das Mutex-Hanlde bei der Erstellung und gibt es wieder frei bei der Entfernung.

Tatsächlich gibt CMutexLock die Mutex-Ressourcen frei und löscht sie, wenn sie die Klammer '}' verlassen. Die erforderliche Flexibilität wird auf diese Weise erzielt

//------------------------------------------------------------------    class CMutexSync
class CMutexSync
{
  HANDLE64 m_mutex; // Handle des erstellten 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; // Handle des gesperrten Mutex

public:
  CMutexLock(CMutexSync &m, DWORD dwWaitMsec) { m_mutex=m.Get(); const DWORD res=WaitForSingleObjectX(m_mutex, dwWaitMsec); } // Mutex-Object der beabsichtigten Verwendung
  ~CMutexLock() { ReleaseMutexX(m_mutex); } // Freigabe des entfernten Mutex-Objektes
};

Durch das Prinzip der Sperrung von Mutex wird der Code leicht lesbar. Es macht die Verwenden von WinAPI Funktionen überflüssig.

Beispiel

In diesem Beispiel synchronisieren wir den Betrieb von Zyklen von zwei Skripte auf zwei Charts.

Das erste Skript führt einige Operationen zu lange durch (2 Sekunden im Beispiel). Das zweite Skript führt seine Operationen viel schneller aus (0.2 Sekunden).

Unsere Aufgabe ist es, nicht zu erlauben, dass eine neue Iteration des schnellen Skripts erfolgt, solange das erste Skript seine aktuelle Iteration nicht beendet hat.

input int sleep=200;

//------------------------------------------------------------------
void OnStart()
{
        Sleep(5000); // warten auf das Skript des anderen Charts
        CMutexSync sync; // das Objekt der Synchronisation
        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); // Sperren des Mutex innerhalb dieser Klammern // hier passiert das Warten und Sperren des Mutex
                Print(Symbol()+" lock scope"); Sleep(sleep);
        }
}

Ergebnis

32/64 Ready

Die Bibliothek arbeitet unter Berücksichtigung der 32/64-bit ähnlich wie MemMap.

Ich wünsche Ihnen viel Glück und große Gewinne!