Was sind die Wissenspunkte der Linux-Multithread-Programmierung?

Linux-Threads sind in zwei Kategorien unterteilt: Eine sind Support-Threads auf Kernebene und die andere sind Threads auf Benutzerebene. Im Allgemeinen handelt es sich um Threads auf Benutzerebene.

1. Mehrere allgemeine Funktionen von Multithreading

Um Multithreads zu erstellen, müssen Sie die Datei pthread.h und die Bibliotheksdatei pthread laden. Die Thread-ID pthread_t ist in der Header-Datei /usr/include/bits/pthreadtypes.h definiert: typedef unsigned long int pthread_t

1. Erstellen Sie einen Thread:

int pthread_create(pthread_t *restrict thread,
const pthread_attr_t *restrict attr , (Void *( *Start_routine) (void *), void *restrict arg); Es wird ein Fehlercode zurückgegeben


2. Warten Sie auf das Ende des angegebenen Threads:


int pthread_join(pthread_t thread,void **value_ptr);
Parameter:
Eine gültige Thread-ID für Thread value_ptr ist ein zu empfangender Zeiger Der vom Thread zurückgegebene Wert. Hinweis: Der Thread, der diese Funktion aufruft, befindet sich in einem angehaltenen Zustand oder kehrt direkt mit einem Fehler zurück, bevor der angegebene Thread beendet wird. Wenn value_ptr nicht null ist, zeigt value_ptr auf den Zeiger des Thread-Rückgabewerts Wenn die Funktion erfolgreich ist, werden die vom angegebenen Thread verwendeten Ressourcen freigegeben.

3. Verlassen Sie den Thread:

int pthread_exit(void * value_ptr);
Parameter:
Value_ptr Thread-Rückgabewertzeiger
Hinweis: ptrhead_exit() verlässt den Thread, der diese Funktion aufruft, und gibt die vom Thread belegten Ressourcen frei .

4. Holen Sie sich die aktuelle Thread-ID:

pthread_t pthread_self(void); ( pthread_mutex_ t* mutex einschränken,
                    const pthread_mutexattr_t *restrict attr);
Parameter:
        Mutex-Ausgabe-Mutex-ID
     attr-Mutex-Attribut, Standard null

Hinweis: Die Funktion gibt erfolgreich 0 zurück, andernfalls gibt sie einen Fehlercode zurück Bsp.:

int pthread_mutex_ lock(pthread_mutex_t *mutex);
Parameter:

Mutex-Mutex-ID

Hinweis: Wenn die angegebene Mutex-ID gesperrt wurde, bleibt der aufrufende Thread in einem angehaltenen Zustand, bis die Mutex-ID vollständig entsperrt ist, andernfalls wird der Mutex deaktiviert gesperrt.
int pthread_mutex_trylock(pthread_mutex_t *mutex);
Parameter:
Mutex-Mutex-ID

Hinweis: Wenn die angegebene Mutex-ID gesperrt wurde, wird direkt ein Fehler zurückgegeben und anhand der Beurteilung dieses Fehlers wird eine andere Verarbeitung durchgeführt. pthread_mutex_trylock ähnelt pthread_mutex_lock, außer dass pthread_mutex_trylock nur blockiert, wenn der Mutex gesperrt ist.

Entsperren Sie den Mutex:
int pthread_mutex_unlock(pthread_mutex_t *mutex);

Parameter:

Mutex-Mutex-ID
Hinweis: Wenn die angegebene Mutex-ID gesperrt wurde, entsperren Sie sie.
Geben Sie den Mutex frei:
int pthread_mutex_destroy(pthread_mutex_t * mutex);
Parameter:
Mutex-Mutex-ID
Hinweis: Geben Sie die vom angegebenen Mutex belegten Ressourcen frei.
Die Funktionen pthread_mutex_init und pthread_mutex_destroy sind der Konstruktor bzw. Destruktor der Mutex-Sperre. 2. Multi-Thread-Synchronisation innerhalb des kritischen Abschnitts abgeschlossen sind oder keine ausgeführt werden.
◎Einzigartigkeit: Wenn ein Thread einen Mutex sperrt, kann kein anderer Thread den Mutex sperren, bis er ihn entsperrt.
◎Nicht ausgelastetes Warten: Wenn ein Thread einen Mutex gesperrt hat und ein zweiter Thread versucht, den Mutex zu sperren, wird der zweite Thread angehalten (ohne CPU-Ressourcen zu belegen), bis der erste Thread den Mutex entsperrt.


2. Bedingungsvariable

Bedingungsvariable ist ein Mechanismus, der es einem Thread ermöglicht (ohne CPU zu verbrauchen), auf das Eintreten bestimmter Ereignisse zu warten. Einige Threads warten möglicherweise auf eine Bedingungsvariable, bis ein anderer Thread ein Signal an die Bedingungsvariable sendet. Zu diesem Zeitpunkt wacht einer dieser Threads auf und verarbeitet das Ereignis. Da die Bedingungsvariable jedoch keine Sperre bereitstellt, muss sie mit einem Mutex verwendet werden, um beim Zugriff auf diese Umgebungsvariable die erforderliche Sperre bereitzustellen.
3. Semaphore
dijkstra schlug das Konzept des Semaphors vor. Das Semaphor ist eine spezielle Variable, die nur positive Ganzzahlwerte annehmen kann: p-Operation (die Warte- und Schließoperationen darstellt). Stellt Signal dar, Öffnungsbetrieb). Die
p/v-Operation ist wie folgt definiert (vorausgesetzt, wir haben ein Semaphor-Sem):
p(sem): Wenn der Wert von sem größer als 0 ist, wird sem um 1 reduziert; wenn der Wert von sem 0 ist Thread ist ausgesetzt.
v (sem): Wenn andere Prozesse angehalten sind und auf Sem warten, wird die Ausführung fortgesetzt. Wenn kein Thread angehalten ist und auf Sem wartet, wird Sem um 1 erhöht.
Erstellung und Öffnung des Signalsatzes
int semget(key_t key,int nsems,int flag);
Betrieb des Semaphors
int semop(int semid,struct sembuf semoparray[],size_t nops);
Steuerung des Semaphors
int semctl( int semid,int semnum int cmd,union semun arg);
Anhang: Das klassische Producer-Consumer-Problem (Produzent-Kunden) ist ein bekanntes Synchronisationsproblem.

Das obige ist der detaillierte Inhalt vonWas sind die Wissenspunkte der Linux-Multithread-Programmierung?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!