Pox mutex in c

„Die Verwendung von Mutex ist die Methode zur Verhinderung von Rassensituationen, die am häufigsten verwendet werden. Mutex, das sich auf den gegenseitigen Ausschluss bezieht, gibt uns im Wesentlichen ein Sackschraubenschloss, das mehrere Benutzer daran hindert, gleichzeitig auf die entscheidenden Daten zuzugreifen und zu modifizieren. Immer wenn mehrere oder mehr Prozesse den gleichen Prozess wie ihr Medium für die Bearbeitung ihrer Verarbeitung anwenden, muss Deadlock vermieden werden. Das Hauptthema der heutigen Diskussion wird die POSIX -MUTEX -Funktion verwenden, um Deadlock mit unterschiedlichen Methoden mit C -Sprache in Ubuntu 20 zu vermeiden.04 System. Bevor wir mit Ihren Code -Snippets etwas tun, sollten wir den GCC -Compiler installieren.”

Beispiel 01

Wir werden unsere erste Illustration von POSIX -MUTEX -Funktionen mit den benötigten Headern beginnen. Ohne diese Header kann unser Skript von C nicht so betrieben werden, wie wir es wollen. Der erste Stdio.H Header ist für die Verwendung regelmäßiger Eingänge und Ausgänge im Code verantwortlich. Der Standard -STDLIB -Header ist für die reibungslose Verwendung von Standardbibliotheksfunktionen im Code -Snippet verantwortlich. Die Unistd.H Header ist ein Muss, um Probleme im Zusammenhang mit Unicodes zu treffen. Hier kommt die Bibliothek, um String -Variablen und -Funktionen zu verwenden, die sich auf die String in C -Sprache beziehen, i, i.e., Saite.H.

Schließlich ist die Bibliothek das „PThread.H ”Kopfzeile, der ein Muss ist, wenn Sie Multithreading in Ihren Snippets verwenden möchten. Diese Bibliothek enthält Thread -Erstellung, Thread -Verbindungen, Thread -Sperren, Thread -Entsperren und viele andere Funktionen, die sich auf Multithreading beziehen.

#enthalten
#enthalten
#enthalten
#enthalten
#enthalten

Nachdem wir die notwendigen Header abgeworfen haben, werden wir 2 Threads mit dem Objekt "pThread_t" aus der Thread -Bibliothek initialisieren. Der Wert „T“ wird in naher Zukunft als Thread -ID verwendet. Dann wird eine Ganzzahlvariable "i" auf 0 initialisiert, und die variable "C" wurde für das Zählen der Threads deklariert. Das mutex -Sperrobjekt "ML" wurde unter Verwendung des Objekts pThread_mutex_t generiert. Hier kommt die Thread -Funktion "T", die den Thread sperren und entsperren wird. Um den aufrufenden Thread zu sperren, verwenden wir die Funktion pThread_mutex_lock () mit der "ML" -Schress, während die Threadnummer gezählt wird.

Die printf () -Anweisungen sind hier, um uns über die Initialisierung und das Ende eines bestimmten Threads zu informieren. Innerhalb der Initialisierung und in der End. Am Ende wird die Funktion pThread_mutex_unlock () verwendet, um den spezifischen Thread zu entsperren und Zugriff auf andere Threads zu erhalten.

pthread_t t [2];
int i = 0;
int c;
pthread_mutex_lock (& ​​ml);
nicht signiert lang i = 0;
C += 1;
printf ("initiiert %d Thread… \ n", c);
für (i = 0; i<(0xFFFFFFFF); i++)
;
Schlaf (5);
printf ("End %d Thread… \ n", c);
Schlaf (5);
pthread_mutex_unlock (& ​​ml);
null zurückkehren;

Die Funktion main () beginnt mit der Anweisung „if“, die einige Bedingungen überprüft hat. Es verwendet die Funktion pThread_mutex_init (), indem es das Lock -Objekt „Ml“ übergeben und Nullwert zur Initialisierung der Mutex -Sperre initialisiert. Wenn der zurückgegebene Wert der init () Funktion nicht gleich 0 ist, zeigt die Anweisung printf () an, dass die Mutex -Sperre nicht aufgrund eines Problems initialisiert wurde. In der Zwischenzeit verwendet die while () Schleife die Bedingung für die variable „I“, die weniger als 2 betragen sollte. Wenn es weniger als 2 ist, wird die Funktion thread_create () aufgerufen, indem Thread -ID "T" als Zeiger und Zeiger auf die Thread -Funktion "T" übergeben wird. Wenn der Thread erfolgreich erstellt würde, würde er "0" zur Variablen "E" zurückgeben.

Falls es andere als 0 zurückgibt, druckt es ein, i, ich.e., Verwenden Sie die Strerrorfunktion und erhöhen Sie den Wert einer Variablen "I". Diese Funktion ist für das Aufrufen der Thread -Funktion t für zwei verschiedene Threads verantwortlich. Die Funktion pThread_join () verwendet Thread -ID, um sie mit der Funktion main () zu verbinden, und die Funktion pThread_mutex_destroy () ist hier, um das Schloss zu zerstören, nachdem alle Funktionen ausgeführt wurden. Die Rückkehr zu einer Main () -Meldung wird am Ende dieses Programms nach Thread -Ausführungen angezeigt.

int main ()
if (pthread_mutex_init (& ml, null) != 0)
printf ("mutex lock nicht initialisieren ... \ n");
Rückkehr 1;

während ich<2)
int e = pthread_create (& t [i], null, & t, null);
if (e != 0)
printf ("nicht erstellt Thread: [%s]", Strerror (e));
i ++;

pthread_join (t [0], null);
pthread_join (t [1], null);
pthread_mutex_destroy (& ml);
printf ("Hallo! Wir sind wieder in der Hauptmethode… \ n ");
Rückkehr 0;

Wir kompilieren den Test.c Datei mit dem "GCC" -Kompiler und dem Option -lpThread für Threads -Ausführung. Die Ausführung zeigt, dass der erste Thread Zugriff auf die Funktion „T“ erhielt und gesperrt wurde.

Nachdem das Schloss aus dem ersten Thread freigesetzt wurde, wurde der Zugriff auf die T -Funktion zum zweiten Thread gegeben und es wurde auch gesperrt und entsperrt.

Am Ende wurden beide Threads ausgeführt, und die main () -Funktion erhielt die Kontrolle zurück.

Beispiel 02

Hier kommt eine weitere Möglichkeit, die Verwendung von POSIX mutex zum Sperren und Entsperren der Threads zu demonstrieren. In diesem Beispiel benötigen wir die Unistd nicht.H Kopfball, also werden wir es nicht benutzen. Andernfalls sind alle Header hier, die wir im obigen Beispiel verwendet haben. Das Objekt pThread_mutex_t wird verwendet, um eine Mutex -Sperre "ml" zu erstellen. Die main () -Methode beginnt mit der Initialisierung von zwei Threads, T1 und T2, mithilfe des Objekts pThread_t. Es verwendet die Funktion pThread_create () zweimal, um Threads zu erstellen, indem Funktionen T1 und T2 aufgerufen werden, indem sie Thread -Initialisierungs -IDs als Zeiger übergeben.e., T1 und T2. Bei der Erstellung von Thread wurden die Funktion T1 und T2 nacheinander ausgeführt. Jede dieser Funktionen wird als Test () -Funktion bezeichnet, indem 2 Zeichenfolgewerte als Parameter bestanden werden.

Die Testfunktion wird hier verwendet, um bestimmte Threads zu sperren und zu entsperren, die sie aufrufen, i, ich.e., T1 und T2. Zur Verriegelung der Threads wird die Funktion pThread_mutex_lock () verwendet, und zum Entsperren wird die Funktion pThread_mutex_unlock () verwendet, i, i.e., Beide verwenden das MUTEX -Schloss „ML“. Innerhalb des Verriegelungs- und Entsperrenprozesse. Die erste printf () -Methode zeigt das erste Argument an, das an die Testfunktion übergeben wurde, und die zweite printf () -Methode zeigt das an die Testfunktion übergebene zweite String -Argument an.

#enthalten
#enthalten
#enthalten
#enthalten
pthread_mutex_t ml;
void* test (char* p, char* q)
pthread_mutex_lock (& ​​ml);
printf ("%s ... \ n", p);
Schlaf (5);
printf ("%s ... \ n", q);
Schlaf (5);
pthread_mutex_unlock (& ​​ml);

void* t1 (void* z)
Test ("initiiert", "1. Thread");
void* t2 (void* z)
Test ("initiiert", "2. Thread");
int main ()
pthread_t t1, t2;
pthread_create (& t1, null & t1, null);
pthread_create (& t2, null & t2, null);
while (1)
exit (0);

Beim Kompilieren wird es Ihnen eine Warnung zeigen, aber Sie können sie für einen Moment ignorieren.

Die Ausführung des kompilierten Codes zeigt, dass der erste Thread initiiert wurde und alle Ressourcen der Testfunktion erhielt.

Danach wurde das Schloss veröffentlicht und der 2. Thread erhielt die Ressourcen. Nach dem zweiten Thread müssen wir die Ausführung mit gewaltsamer verlassen.

Abschluss

Das POSIX -MUTEX -Konzept wird kurz erklärt, um Deadlock in der C -Programmierung zu vermeiden. Daher haben wir die Funktionen pThread_mutex_lock und pthread_mutex_unlock verwendet, um dies auszuführen. Mit diesen Funktionen in unseren Code -Snippets haben wir die Verwendung von Ressourcen für einen Thread gleichzeitig sichergestellt.