C ++ stdmutex/

Durch die Verwendung des Keywords von Mutex können wir unsere Variable von mehreren Threads gleichzeitig zugreifen lassen. Mutex wird verwendet, um die Synchronisation in C ++ bereitzustellen, was bedeutet, dass nur ein Thread das Objekt sofort empfangen kann. Threads können nicht auf das gesperrte Stück Code zugreifen, sobald das Schloss festgelegt wurde. Der Code wurde unter Verwendung von Mutexes gesperrt. Selbst wenn Thread 2 geplant ist, während Thread 1 die freigegebene Ressource immer noch verbraucht, kann Thread 2 nicht auf diesen Teil des Codes zugreifen. Infolgedessen ist der synchronisierte Zugriff auf gemeinsam genutzte Ressourcen im Code gewährleistet.

Arbeiten von Mutex in c++

Betrachten Sie eine Situation, in der ein Thread einen Codeabschnitt ausführt, den ein Mutex gesperrt hat. Wenn der Scheduler nun beschließt, den Kontext zu ändern. Nur ein Thread aus allen anderen könnte dies erreichen können, aber wenn dieser Thread versuchte, einen gesperrten Teil des Code auszuführen.

Es gibt wiederholte Kontextschalter, aber bis die Mutex -Sperrung über den gesperrten Codeabschnitt befreit wird, kann kein Thread es ausführen. Ein Faden, der einen Mustex sperrte.

Daher stellt dies sicher, dass ein Thread, sobald ein Thread einen Teil des Codes sperrt, kein anderer Thread diesen Bereich ausführen kann.

Während dieses Systems mit gemeinsamen Ressourcen funktioniert, stellt er sicher, dass die Threads synchronisiert sind.

Durch das Aufrufen der beiden folgenden Funktionen wird ein Mutex initialisiert und dann wird ein Schloss erreicht: Die erste Methode initialisiert einen Mutex und die zweite Funktion ermöglicht die Sperre von einem entscheidenden Codeabschnitt.

# Int pthread_mutex_init (pthread_mutex_trylock *einschränken mutex, const pthread_mutexattribute_trylock *einschränken Attribut):
Liefert einen Mutex mit den durch das Attribut definierten Eigenschaften und einen Verweis auf einen anderen Mutex. Die Standard -Mutex -Eigenschaft (nicht rekursiv) wird verwendet, wenn das Attribut null ist. Wenn pthread mutex init () erfolgreich ist, gibt es 0 zurück und initialisiert und entsperren den Zustand des Mutex. Pthread mutex init () gibt -1 zurück, wenn es nicht erfolgreich ist.

# int pthread_mutex_lock (pthread_mutex_trylock *mutex):
Klassifiziert einen Mutex und sperrt ein Mutex -Objekt. Der vorhandene Thread sollte warten, bis der Mutex freigeschaltet wird, wenn er zuvor von einem anderen Thread gesperrt wurde. Ein Mutex wird durch den Faden gesperrt, der ihn gesperrt hat, und dieser Faden ist weiter. Die Art und Weise, wie ein Schloss verwendet wird. Wenn derselbe Faden mehr als einmal den gleichen Mutextyp sperrt, wird die Anzahl erhöht und kein Wartephread erstellt.

Um die Anzahl auf Null zu verringern, muss der besitzende Thread eine gleiche Anzahl von Aufrufen an pThread_mutex_unlock () ergeben.Bei Erfolg gibt die Funktion pThread_mutex_lock () 0 zurück. Pthread_mutex_lock () gibt -1 zurück, wenn es fehlschlägt.

Durch die Ausführung der beiden unten angegebenen Aktionen kann der Mutex freigeschaltet und zerstört werden. Das Schloss kann mit der ersten Technik geöffnet werden und es kann auch zerstört werden, so dass es in Zukunft nicht verwendet werden kann.

# int pthread_mutex_unlock (pthread_mutex_trylock *mutex):
Das Mutex -Objekt wird freigegeben. Wenn mehrere oder mehr Threads anstehen, um den Mutex zu blockieren, zwingt PThread Mutex entsperr () einen der Threads dazu, dies zu tun. Es zwingt es auch, mit dem Objekt Mutex, den es zuvor erhalten hatte. Der Mutex entsperren, es sei denn, keine Fäden warten auf und hat momentan keinen Besitzer. Die Verwendung der Schloss kann sich ändern, wenn der Mutex das rekursive Merkmal hat.

Wenn derselbe Faden mehr als einmal einen bestimmten Mutex sperrt, wird die Anzahl beim Entsperren verringert, und es wird kein Wartefaden erstellt, um das Schloss aufrechtzuerhalten. Der Mutex wird entfernt und wartende Threads veröffentlicht, wenn die Anzahl auf Null liegt. Pthread_mutex_unlock () gibt 0 zurück, wenn erfolgreich. Pthread_mutex_unlock () gibt -1 zurück.

int pthread_mutex_destroy (pthread_mutex_trylock *mutex): Entfernt ein Mutex -Objekt. Manchmal wird es als Mutex -Kennung aus dem System bezeichnet. Mutexes werden zum Schutz der gemeinsamen Ressourcen verwendet. Der Mutex wird mit einem fehlerhaften Wert initialisiert, aber pthread mutex init ermöglicht eine Wiederinitialisierung () (). Der erfolgreiche Rückgabewert von pthread_mutex_destroy () beträgt 0, 0. PThread_mutex_destroy () gibt -1 zurück.

Beispiel von Mutex in c++

Eine Abbildung, wie die Threadsynchronisation mit Mutexes erreicht wird.

Hier haben wir zuerst die Thread -ID -Größe "3" gegeben. Als nächstes haben wir den Variablenzähler initialisiert, der die Frequenz mit den ausgeführten Threads aufzeichnet. Anschließend haben wir das Objektschloss für das pThread_mutex_lock erstellt. Danach haben wir eine Funktion "mutex_func" festgelegt, in der wir die Sperrreferenz übernommen und die Variable "M" mit Null initialisiert haben. Der inkrementelle Wert wird in die Zählervariable eingegeben.

Jetzt haben wir die Hauptfunktion dieses Skripts definiert. Die beiden Variablen werden deklariert, eine für Mutex als „M“ und eine für das Versagen von Mutex als „Fehler“. Wenn die Methode „mutex func ()“ den gemeinsam genutzten Ressource „Zähler“ verwendet, ist derselbe Mutex gesperrt. Der identische Mutex wird nach der Funktion "mutex_func ()" entsperrt ". Der Mutex wird gelöscht, sobald beide Threads die Hauptfunktion abgeschlossen haben. Beachten Sie, dass jeweils nur zwei Aufgaben ausgeführt werden.

In der Ausgabe können Sie feststellen, dass ein Thread begonnen hat. Sobald der laufende Thread nicht zerstört wurde, ist die andere Aufgabe, die nicht begonnen hat, die Aufgabe. Daher sind beide Jobs begonnen und die Endprotokolle vorhanden. Somit die Verwendung von mutex -fähiger Threadsynchronisation.

Abschluss

Wir können das Objekt sperren, das die wesentliche Funktionalität unserer Anwendung mit einem Mutex enthält. Darüber hinaus werden inkonsistente Daten vermieden, was für Echtzeitanwendungen von entscheidender Bedeutung ist. Zum Beispiel, wie die Synchronisation in anderen Programmiersprachen implementiert wird, wird Mutex verwendet. Wir haben ein Beispiel aufgenommen, um das Konzept von std :: mutex auch in der C ++ - Programmiersprache zu erklären.