C++ ist bekanntlich eine der schnellsten Programmiersprachen mit guter Performance, hoher Präzision und einem adäquaten Speicherverwaltungssystem. Diese Programmiersprache unterstützt auch die gleichzeitige Ausführung mehrerer Threads mit der gemeinsamen Nutzung mehrerer Ressourcen zwischen ihnen. Beim Multithreading soll der Thread nur den Lesevorgang ausführen, der keine Probleme verursacht, da der Thread nicht von dem beeinflusst wird, was die anderen Threads zu diesem Zeitpunkt tun. Aber wenn diese Threads die Ressourcen untereinander teilen mussten, kann ein Thread die Daten zu diesem Zeitpunkt ändern, was das Problem verursacht. Um dieses Problem zu lösen, haben wir den C++ „Mutex“, der den Zugriff mehrerer Ressourcen auf unseren Code/Objekt verhindert, indem er die Synchronisation bereitstellt, die besagt, dass der Zugriff auf das Objekt/den Code nur einem Thread gleichzeitig gewährt werden kann. so dass mehrere Threads nicht gleichzeitig auf dieses Objekt zugreifen können.
Verfahren:
Wir werden erfahren, wie wir den Zugriff mehrerer Threads auf ein Objekt gleichzeitig mit der Mutex-Sperre stoppen können. Wir werden über die Syntax der Mutex-Sperre sprechen, was ist Multiple Threading und wie wir mit den Problemen umgehen können, die durch Multiple Threading mit der Mutex-Sperre verursacht werden. Dann nehmen wir ein Beispiel für das Multiple Threading und implementieren die Mutex-Sperre darauf.
Syntax:
Wenn wir lernen möchten, wie wir die Mutex-Sperre implementieren können, um den gleichzeitigen Zugriff mehrerer Threads auf unser Objekt oder unseren Code zu verhindern, können wir die folgende Syntax verwenden:
$Std :: mutex mut_x
$mut_x. sperren ( ) ;
Ungültiger Funktionsname ( ) {
$ // Code, den wir vor den mehreren Threads verbergen möchten, würde hier geschrieben werden
$mut_x. entsperrt ( ) ;
}
Wir werden diese Syntax nun im Dummy-Beispiel und im Pseudocode (den wir nicht einfach so wie er ist im Code-Editor ausführen können) verwenden, um Ihnen mitzuteilen, wie wir diese Syntax wie im Folgenden erwähnt genau verwenden können:
$Std :: mutex mut_x
Leerer Block ( ) {
$mut_x. sperren ( ) ;
$Std :: cout << 'hallo' ;
$mut_x. entsperrt ( ) ;
}
Beispiel:
Lassen Sie uns in diesem Beispiel versuchen, zuerst die Multithread-Operation zu erstellen und diese Operation dann mit Mutex-Sperren und -Entsperren zu umgeben, um die Synchronisierung der Operation mit dem erstellten Code oder Objekt bereitzustellen. Mutex befasst sich mit Wettlaufbedingungen, bei denen es sich um ziemlich unvorhersehbare Werte handelt, die vom Umschalten der zeitbewussten Threads abhängen. Um das Beispiel für Mutex zu implementieren, müssen wir zunächst die wichtigen und benötigten Bibliotheken aus den Repositories importieren. Die erforderlichen Bibliotheken sind:
$ #
$ #
$ #
Die „iostream“-Bibliothek stellt uns eine Funktion zur Verfügung, um die Daten als Cout anzuzeigen, die Daten als Cin zu lesen und die Anweisung als endl zu beenden. Wir verwenden die „Thread“-Bibliothek, um die Programme oder Funktionen aus den Threads zu nutzen. Die „Mutex“-Bibliothek ermöglicht es uns, sowohl die Mutex-Sperre als auch die Mutex-Entsperrung im Code zu implementieren. Wir verwenden das „# include“, weil es alle Programme erlaubt, die sich auf die Bibliothek beziehen, die im Code enthalten ist.
Nachdem der vorherige Schritt abgeschlossen ist, definieren wir nun die Mutex-Klasse oder eine globale Variable für den Mutex mit der std. Dann erstellen wir eine Funktion zum Sperren und Entsperren von Mutex, die wir später im Code aufrufen könnten. In diesem Beispiel nennen wir diese Funktion als Block. Im Hauptteil der Blockfunktion rufen wir zuerst „mutex.lock()“ auf und beginnen mit dem Schreiben der Logik des Codes.
Die mutex.lock () verweigert den Zugriff der anderen Threads, um unser erstelltes Objekt oder unseren Code zu erreichen, sodass jeweils nur ein Thread unser Objekt lesen kann. In der Logik führen wir eine for-Schleife aus, die auf dem Index von 0 bis 9 läuft. Wir zeigen die Werte in der Schleife an. Sobald diese Logik in der Mutex-Sperre erstellt ist, nachdem ihre Operation abgeschlossen ist oder nachdem die Logik verlassen wurde, rufen wir die Methode „mutex.unlock()“ auf. Dieser Methodenaufruf ermöglicht es uns, das erstellte Objekt von der Mutex-Sperre zu entsperren, da der Zugriff des Objekts auf einen einzelnen Thread früher bereitgestellt wurde und sobald die Operation an diesem Objekt jeweils von einem Thread ausgeführt wird. Wir möchten jetzt, dass die anderen Threads auch auf dieses Objekt oder diesen Code zugreifen. Andernfalls bewegt sich unser Code in die „Deadlock“-Situation, was dazu führt, dass das erstellte Objekt mit dem Mutex für immer in der gesperrten Situation verbleibt und kein anderer Thread auf dieses Objekt zugreifen kann. Daher wird eine unvollständige Operation weiterhin ausgeführt. Danach verlassen wir die Blockfunktion und gehen zur Hauptansicht.
In der Hauptsache zeigen wir unseren erstellten Mutex einfach an, indem wir die drei Threads mithilfe von „std :: thread thread_name (Aufruf der bereits erstellten Blockfunktion hier, in der wir den Mutex erstellt haben)“ mit den Namen Thread1, Thread2 und Thread3 usw. erstellen Auf diese Weise werden die drei Threads erstellt. Wir verbinden dann diese drei Threads, damit sie gleichzeitig ausgeführt werden, indem wir die Datei „thread_name. join ()“-Methode. Und dann geben wir den Wert gleich Null zurück. Die zuvor erwähnte Erläuterung des Beispiels ist in Form des Codes implementiert, der in der folgenden Abbildung dargestellt werden kann:
In der Ausgabe des Codes können wir die Ausführung und Anzeige aller drei Threads nacheinander sehen. Wir können sogar sehen, ob unsere Anwendung unter die Kategorie Multithreading fällt. Dennoch hat keiner der Threads die Daten überschrieben oder geändert und die geänderte Ressource aufgrund der Implementierung des Mutex des „Funktionsblocks“ gemeinsam genutzt.
Fazit
Dieses Handbuch enthält eine detaillierte Erläuterung des Konzepts der Mutex-Funktion, die in C++ verwendet wird. Wir haben diskutiert, was Multithreading-Anwendungen sind, welche Probleme wir bei Multithreading-Anwendungen haben und warum wir den Mutex für Multithreading-Anwendungen implementieren müssen. Wir haben dann die Syntax für den Mutex mit dem Dummy-Beispiel unter Verwendung des Pseudo-Codes besprochen. Dann haben wir ein vollständiges Beispiel für die Multithreading-Anwendungen mit dem Mutex im C++ Visual Studio implementiert.