Quels sont les points de connaissance de la programmation multithread Linux ?

Les threads Linux sont divisés en deux catégories : l'une est constituée des threads de support au niveau principal et l'autre est celle des threads au niveau de l'utilisateur. Généralement, ce sont des threads au niveau de l'utilisateur.

1. Plusieurs fonctions courantes du multi-threading

Pour créer du multi-thread, vous devez charger le fichier pthread.h et le fichier bibliothèque pthread. L'identifiant du fil pthread_t est défini dans le fichier d'en-tête /usr/include/bits/pthreadtypes.h : typedef unsigned long int pthread_t

1 Créer un fil :

int pthread_create(pthread_t *restrict thread,
const pthread_attr_t *restrict attr. , (Void *( *Start_routine) (void *), void *restrict
paramètre :
ID du fil de sortie du fil
Attribut du fil Attr, paramètre d'exécution du fil null par défaut
paramètre d'exécution du thread start_routine paramètre d'exécution : lettre : le nombre de succès renvoie 0 Sinon, un code d'erreur est renvoyé


2. Attendez la fin du fil spécifié :

int pthread_join(pthread_t thread,void **value_ptr);
Paramètres :

Un identifiant de fil valide pour le fil value_ptr est un pointeur à recevoir la valeur renvoyée par le thread

note : Le thread appelant cette fonction sera dans un état suspendu ou reviendra directement avec une erreur avant la sortie du thread spécifié. Si value_ptr n'est pas nul, value_ptr pointe vers le pointeur de la valeur de retour du thread After. la fonction réussit, les ressources utilisées par le thread spécifié seront libérées.


3. Quittez le fil :

int pthread_exit(void * value_ptr);

Paramètres :
Value_ptr thread return value pointer

note : ptrhead_exit() quitte le thread qui appelle cette fonction et libère les ressources occupées par le thread. .

4. Obtenez l'identifiant du fil actuel :

pthread_t pthread_self(void);

Paramètres :
note : renvoie l'identifiant de la fonction actuelle

5. _init( pthread_mutex_ t* restrict mutex,
                      const pthread_mutexattr_t *restrict attr);
Paramètre :

         identifiant mutex de sortie mutex

     attribut mutex attr, valeur par défaut
remarque : la fonction renvoie 0 avec succès, sinon elle renvoie un code d'erreur

Lock le mutex :

int pthread_mutex_ lock(pthread_mutex_t *mutex);
Paramètre :
identifiant mutex mutex
remarque : si l'identifiant mutex spécifié a été verrouillé, le thread appelant restera dans un état suspendu jusqu'à ce que l'identifiant mutex soit complètement déverrouillé, sinon le mutex sera fermé.
int pthread_mutex_trylock(pthread_mutex_t *mutex);
Paramètres :
Identifiant mutex mutex
remarque : Si l'identifiant mutex spécifié a été verrouillé, une erreur sera renvoyée directement et un traitement différent sera effectué en jugeant cette erreur. pthread_mutex_trylock est similaire à pthread_mutex_lock, sauf que pthread_mutex_trylock ne bloque que lorsque le mutex est verrouillé.
Déverrouillez le mutex :
int pthread_mutex_unlock(pthread_mutex_t *mutex);
Paramètre :
identifiant mutex mutex
remarque : Si l'identifiant mutex spécifié a été verrouillé, déverrouillez-le
Relâchez le mutex :
int pthread_mutex_destroy(pthread_mutex_t * mutex);
Paramètres :
mutex mutex id
note : Libère les ressources occupées par le mutex spécifié.
Les fonctions pthread_mutex_init et pthread_mutex_destroy sont respectivement le constructeur et le destructeur du verrou mutex.

2. Synchronisation multi-thread

1. Mutex


Un mutex (mutex) est équivalent à un verrou, qui peut garantir les trois points suivants :
◎Atomicité : Si un thread verrouille un mutex, alors Soit toutes les opérations dans la section critique sont terminés ou aucun n'est exécuté.

◎Unicité : si un thread verrouille un mutex, aucun autre thread ne peut verrouiller le mutex jusqu'à ce qu'il le déverrouille.

◎Attente non occupée : si un thread a verrouillé un mutex et qu'un deuxième thread tente de verrouiller le mutex, le deuxième thread sera suspendu (sans occuper de ressources CPU) jusqu'à ce que le premier thread déverrouille le mutex.

2. Variable de condition

La variable de condition est un mécanisme qui permet à un thread (sans consommer de CPU) d'attendre que certains événements se produisent. Certains threads peuvent attendre une variable de condition jusqu'à ce qu'un autre thread envoie un signal à la variable de condition, moment auquel l'un de ces threads se réveillera et gérera l'événement. Mais la variable de condition ne fournit pas de verrouillage, elle doit donc être utilisée avec un mutex pour fournir le verrouillage nécessaire lors de l'accès à cette variable d'environnement.
3. Sémaphore
dijkstra a proposé le concept de sémaphore. Le sémaphore est une variable spéciale qui ne peut prendre que des valeurs entières positives : l'opération p (représentant les opérations d'attente et de fermeture) et l'opération v (. représentant le signal, opération ouverte).
L'opération p/v est définie comme suit (en supposant que nous ayons un sémaphore sem) :
p(sem) : Si la valeur de sem est supérieure à 0, alors sem est réduite de 1 si la valeur de sem est 0, le le fil est suspendu.
v (sem) : Si d'autres processus sont suspendus en attendant sem, laissez-le reprendre l'exécution ; si aucun thread n'est suspendu en attendant sem, sem est augmenté de 1.
Création et ouverture du jeu de signaux
int semget(key_t key,int nsems,int flag);
Fonctionnement du sémaphore
int semop(int semid,struct sembuf semoparray[],size_t nops);
Contrôle du sémaphore
int semctl( int semid,int semnum int cmd,union semun arg);
Pièce jointe : Le problème classique producteur-consommateur (producteur-client) est un célèbre problème de synchronisation.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!