Detaillierte Erläuterung des Linux-Multithread-Synchronisationsmutex Mutex

Linux-System ist ein Betriebssystem, das die gleichzeitige Ausführung mehrerer Aufgaben unterstützt. Es kann mehrere Prozesse gleichzeitig ausführen und dadurch die Systemauslastung und -effizienz verbessern. Wenn jedoch mehrere Threads in einem Prozess vorhanden sind und diese Threads einige Daten oder Ressourcen gemeinsam nutzen müssen, kann es zu Dateninkonsistenzen oder Ressourcenkonkurrenz kommen, was zu Systemfehlern oder Ausnahmen führt. Um dieses Problem zu lösen, müssen Sie einige Synchronisationsmechanismen verwenden, z. B. Semaphore, Bedingungsvariablen, Mutexe usw. Unter diesen ist der Mutex ein relativ einfacher und effektiver Synchronisationsmechanismus. Er ermöglicht es einem Thread, gemeinsam genutzte Daten oder Ressourcen zu sperren, wenn er darauf zugreift, um zu verhindern, dass andere Threads gleichzeitig darauf zugreifen, wodurch die Thread-Sicherheit gewährleistet wird. In diesem Artikel wird die Methode zum Synchronisieren des Mutex-Mutex in Linux-Multithreads ausführlich erläutert, einschließlich der Initialisierung, Sperrung, Entsperrung und Zerstörung des Mutex.

1. Initialisierung:

Unter Linux ist der Mutex-Datentyp des Threads pthread_mutex_t. Vor der Verwendung muss er initialisiert werden:

Für statisch zugewiesenen Mutex können Sie ihn auf PTHREAD_MUTEX_INITIALIZER setzen oder pthread_mutex_init aufrufen.

Für dynamisch zugewiesene Mutexe wird nach der Beantragung von Speicher (malloc) dieser über pthread_mutex_init initialisiert, und pthread_mutex_destroy muss aufgerufen werden, bevor der Speicher (frei) freigegeben wird.

Prototyp:

int pthread_mutex_init(pthread_mutex_t *mutex einschränken, const pthread_mutexattr_t *attr einschränken);

int pthread_mutex_destroy(pthread_mutex_t *mutex);

Header-Datei:

Rückgabewert: 0 bei Erfolg, Fehlernummer, wenn ein Fehler auftritt.

Hinweis: Wenn Sie die Standardattribute zum Initialisieren des Mutex verwenden, setzen Sie attr einfach auf NULL. Andere Werte werden später erklärt.

2. Sich gegenseitig ausschließende Operationen:

Um auf freigegebene Ressourcen zuzugreifen, müssen Sie den Mutex sperren, bis der Mutex entsperrt ist .

Lassen Sie uns über die Sperrfunktion sprechen:

Header-Datei:

Prototyp:

int pthread_mutex_lock(pthread_mutex_t *mutex);

int pthread_mutex_trylock(pthread_mutex_t *mutex);

Rückgabewert: 0 bei Erfolg, Fehlernummer, wenn ein Fehler auftritt.

Erklärung: Lassen Sie uns speziell über die Trylock-Funktion sprechen. Das heißt, wenn der Mutex nicht gesperrt ist, sperrt die Trylock-Funktion den Mutex Mutex ist nicht gesperrt, die Trylock-Funktion sperrt den Mutex und erhält Zugriff auf die gemeinsam genutzten Ressourcen. Die exklusive Funktion ist gesperrt und die Trylock-Funktion blockiert und wartet nicht, sondern gibt direkt EBUSY zurück, was darauf hinweist, dass die gemeinsam genutzte Ressource beschäftigt ist.

Lassen Sie uns noch einmal über die Lösungsfunktion sprechen:

Header-Datei:

Prototyp: int pthread_mutex_unlock(pthread_mutex_t *mutex);

Rückgabewert: 0 bei Erfolg, Fehlernummer, wenn ein Fehler auftritt.

3. Stillstand:

Deadlock tritt hauptsächlich auf, wenn mehrere abhängige Sperren vorhanden sind, und tritt auf, wenn ein Thread versucht, den Mutex in der entgegengesetzten Reihenfolge wie ein anderer Thread zu sperren. Bei der Verwendung von Mutexen sollte besonders darauf geachtet werden, einen Deadlock zu vermeiden.

Generell gibt es mehrere ungeschriebene Grundprinzipien:

Stellen Sie sicher, dass Sie eine Sperre erhalten, bevor Sie gemeinsam genutzte Ressourcen verwenden.

Achten Sie darauf, die Sperre nach Abschluss des Vorgangs aufzuheben.

Wenn mehrere Sperren vorhanden sind und die Erwerbsreihenfolge ABC ist, sollte auch die Freigabereihenfolge ABC sein.

Ein Thread sollte die Sperre aufheben, die er erworben hat, wenn er einen Fehler zurückgibt.

Beispiel:

#include 
#include 
#include 
#include 
#include 

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int lock_var;
time_t end_time;
int sum;

void pthread1(void *arg);
void pthread2(void *arg);
void pthread3(void *arg);

int main(int argc, char *argv[])
{
pthread_t id1,id2,id3;
pthread_t mon_th_id;
int ret;
sum=10;

end_time = time(NULL) 10;
pthread_mutex_init(&mutex,NULL);
ret=pthread_create(&id1,NULL,(void *)pthread1, NULL);
if(ret!=0)
perror("pthread cread1");

ret=pthread_create(&id2,NULL,(void *)pthread2, NULL);
if(ret!=0)
perror("pthread cread2");

ret=pthread_create(&id3,NULL,(void *)pthread3, NULL);
if(ret!=0)
perror("pthread cread3");

pthread_join(id1,NULL);
pthread_join(id2,NULL);
pthread_join(id3,NULL);
exit(0);
}

void pthread1(void *arg)
{
int i;
while(time(NULL) if(pthread_mutex_lock(&mutex)!=0) //lock
{
perror("pthread_mutex_lock");
}
else
printf("pthread1:pthread1 lock the variablen");
for(i=0;iif(pthread_mutex_unlock(&mutex)!=0) //unlock
{
perror("pthread_mutex_unlock");
}
else
printf("pthread1:pthread1 unlock the variablen");
sleep(1);
}
}

void pthread2(void *arg)
{
int nolock=0;
int ret;
while(time(NULL) if(ret==EBUSY)
printf("pthread2:the variable is locked by pthread1n");
else{
if(ret!=0)
{
perror("pthread_mutex_trylock");
exit(1);
}
else
printf("pthread2:pthread2 got lock.The variable is %dn",lock_var);
if(pthread_mutex_unlock(&mutex)!=0)//unlock
{
perror("pthread_mutex_unlock");
}
else
printf("pthread2:pthread2 unlock the variablen");
}
sleep(1);
}
}



void pthread3(void *arg)
{/*
int nolock=0;
int ret;
while(time(NULL) if(ret==EBUSY)
printf("pthread3:the variable is locked by pthread1 or 2n");
else
{
if(ret!=0)
{
perror("pthread_mutex_trylock");
exit(1);
}
else
printf("pthread3:pthread3 got lock.The variable is %dn",lock_var);
if(pthread_mutex_unlock(&mutex)!=0)
{
perror("pthread_mutex_unlock");
}
else
printf("pthread3:pthread2 unlock the variablen");
}
sleep(3);
}*/
}

In diesem Artikel wird ausführlich die Methode zum Synchronisieren des Mutex-Mutex in Linux-Multithreads erläutert, einschließlich der Initialisierung, Sperrung, Entsperrung und Zerstörung des Mutex. Durch das Verständnis und die Beherrschung dieses Wissens können wir Mutexe besser nutzen, um eine Synchronisierung zwischen mehreren Threads zu erreichen und die Stabilität und Effizienz des Systems zu verbessern.

Das obige ist der detaillierte Inhalt vonDetaillierte Erläuterung des Linux-Multithread-Synchronisationsmutex Mutex. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!