Linux-Multithread-Mutex: ein Thread-sicherer Synchronisationsmechanismus

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 gegenseitige Ausschlussmethode von Multithread-Mutex im Linux-System vorgestellt, einschließlich der Initialisierung, Sperrung, Entsperrung und Zerstörung von Mutex.

Synchronisieren

Mehrere Threads im selben Prozess teilen sich die Speicherressourcen des Prozesses. Wenn mehrere Threads gleichzeitig auf dieselbe gemeinsame Ressource zugreifen, müssen sie sich untereinander koordinieren, um Probleme wie Dateninkonsistenz und Überschreibung zu vermeiden und Kommunikation werden als Thread-Synchronisierungsprobleme bezeichnet. Die Idee der Thread-Synchronisierung besteht darin, mehreren Threads den Zugriff auf gemeinsam genutzte Ressourcen nacheinander statt parallel zu ermöglichen

Gegenseitiger Ausschluss vs. Synchronisierung

• Gegenseitiger Ausschluss: bedeutet, dass eine bestimmte Ressource nur einem Besucher gleichzeitig den Zugriff ermöglicht und einzigartig und exklusiv ist. Gegenseitiger Ausschluss kann jedoch nicht die Reihenfolge einschränken, in der Besucher auf Ressourcen zugreifen, d. h. der Zugriff ist ungeordnet. Wenn es sich bei der Operation um eine atomare Operation handelt, schließen sie sich natürlich gegenseitig aus
• Synchronisierung: bezieht sich auf den geordneten Zugriff von Besuchern auf Ressourcen durch andere Mechanismen auf der Grundlage gegenseitigen Ausschlusses (in den meisten Fällen). In den meisten Fällen implementiert die Synchronisierung bereits einen gegenseitigen Ausschluss, insbesondere wenn sich alle Schreibvorgänge auf Ressourcen gegenseitig ausschließen müssen. In einigen Fällen kann mehreren Besuchern gleichzeitig der Zugriff auf Ressourcen gestattet werden

Mutex:

• Im Wesentlichen handelt es sich um eine Sperre, die exklusiven Zugriff auf Ressourcen ermöglicht. Daher besteht die Hauptfunktion von Mutex darin, sich gegenseitig auszuschließen. Ein Mutex ermöglicht nur einem Thread den gleichzeitigen Zugriff auf Daten und kann als eine Art 0/1-Semaphor betrachtet werden
• Die Werte von Mutex-Objekten sind nur 0 und 1. Stellen Sie den Sperrzustand bzw. den Ruhezustand von Mutex dar:
  • Sperrstatus: Das aktuelle Objekt ist gesperrt. Wenn der Benutzerprozess/Thread versucht, kritische Ressourcen zu sperren, wird er in den Wartezustand versetzt Leerlaufzustand: Das aktuelle Objekt ist im Leerlauf, der Benutzerprozess/-thread kann kritische Ressourcen sperren, und dann verringert sich der Mutex-Wert um 1 und wird 0.
  Mutex kann bei seiner Erstellung einen Anfangswert haben, der angibt, ob sich der Mutex nach seiner Erstellung in einem gesperrten Zustand oder einem Ruhezustand befindet.
• Um einen Deadlock zu verhindern, lässt das System im selben Thread nicht zu, dass der Mutex zweimal hintereinander gesperrt wird (das System kehrt normalerweise sofort nach dem zweiten Aufruf zurück). Mit anderen Worten, die beiden entsprechenden Vorgänge zum Sperren und Entsperren müssen im selben Thread ausgeführt werden.

Mutex-Modell

#include 
pthread_mutex_t  mutex                //定义互斥锁               
pthread_mutex_init()            //初始化锁          
pthread_mutex_lock()/pthread_mutex_trylock()  ...     //加锁                  
pthread_mutex_unlock()          //解锁                        
pthread_mutex_destroy()         //销毁                        
//成功返回0,失败返回error number
#include 
int pthread_mutex_init  (pthread_mutex_t *mutex, const pthread_mutexattr_t *mutexattr);
int pthread_mutex_lock  (pthread_mutex_t *mutex);
int pthread_mutex_trylock   (pthread_mutex_t *mutex);
int pthread_mutex_unlock    (pthread_mutex_t *mutex);
int pthread_mutex_destroy   (pthread_mutex_t *mutex);

Deadlock

Deadlock tritt hauptsächlich auf, wenn mehrere abhängige Sperren vorhanden sind, und er tritt auf, wenn ein Thread versucht, den Mutex in umgekehrter Reihenfolge mit einem anderen Thread zu sperren

Wenn der

Black-Ball-Thread die gemeinsam genutzte Ressource in Richtung A-> verwendet und der White-Ball-Thread die gemeinsam genutzte Ressource in der Reihenfolge B->A verwendet, sperrt der
Black-Ball-Thread leider die A-Ressource bis Es erhält die freigegebenen B-Ressourcen, der weiße Ball-Thread sperrt Ressource B, bis er die freigegebene Ressource A erhält. Das Endergebnis ist, dass sie die gewünschten Ressourcen nicht erhalten können und alle die Ressourcen sperren, die die andere Partei möchte

解决死锁：

• 对共享资源操作前一定要获得锁
• 完成操作后一定要释放锁
• 尽量短的时间占用锁
• 如果有多锁，如获得的顺序是ABC顺序，那么释放顺序也该是ABC
• 线程错误返回时会释放它所获得的锁

例子

#include
#include
#include
#include

char* buf[5];
int pos;
//1.定义互斥量
pthread_mutex_t mutex;
void* task(void* pv){
    //3.使用互斥量进行加锁
    pthread_mutex_lock(&mutex);
    
    //4.访问共享内存
    buf[pos]=(char*)pv;
    sleep(1);
    pos++;

    //5.使用互斥量进行解锁
    pthread_mutex_unlock(&mutex);
}
main(){
    //2.初始化互斥量
    pthread_mutex_init(&mutex,NULL);

    pthread_t thread;
    pthread_create(&thread,NULL,task,(void*)"zhangfei");
    pthread_t thread2;
    pthread_create(&thread2,NULL,task,(void*)"guanyu");
    
    pthread_join(thread,NULL);
    pthread_join(thread2,NULL);

    //打印字符指针数组中的有效数据
    int i=0;
    for(i=0;iprintf("%s ",buf[i]);
    }
    printf("\n");
    //6.如果不再使用则销毁互斥量
    pthread_mutex_destroy(&mutex);
    return 0;
}

本文介绍了Linux系统中多线程互斥量的互斥的方法，包括互斥量的初始化、加锁、解锁和销毁等方面。通过了解和掌握这些知识，我们可以更好地使用互斥量来实现多线程之间的同步，提高系统的稳定性和效率。当然，Linux系统中多线程互斥量还有很多其他的特性和用法，需要我们不断地学习和研究。希望本文能给你带来一些启发和帮助。

Das obige ist der detaillierte Inhalt vonLinux-Multithread-Mutex: ein Thread-sicherer Synchronisationsmechanismus. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!